viernes, 6 de enero de 2017

metodo de seleccion directa con ejemplos en diagrama

Diagrama de flujo de ordenamiento por selección directa


Programación de selección directa en c++

#include<iostream.h>
#include<conio.h>
void main()
{clrscr();
int i,j,a[30], aux,menor,n;
cout<<"ingrese el tamaño del vetor: ";
cin>>n;
for(i=1;i<=n;i++)
{  cout<<"vetor["<<(i)<<"]:";
cin>>a[i];
}
for(i=1;i<n;i++)
{ menor=i;
for(j=i+1;j<=n;j++)
{ if (a[j]<a[menor])
{
menor=j;
}
}
aux =a[i];
a[i]=a[menor];
a[menor]=aux;
}
 cout<<"el orden es:"<<endl;
for(i=1;i<=n;i++)
{
 cout<< a[i];
}
 getch();
3.- SELECCION

El ordenamiento por selección (Selection Sort en inglés) es un algoritmo de ordenamiento que requiere O operaciones para ordenar una lista de n elementos
Su funcionamiento es el siguiente:
  • Buscar el mínimo elemento de la lista
  • Intercambiarlo con el primero
  • Buscar el siguiente mínimo en el resto de la lista
  • Intercambiarlo con el segundo
Y en general:
  • Buscar el mínimo elemento entre una posición i y el final de la lista
  • Intercambiar el mínimo con el elemento de la posición i







EJEMPLO:

 

método de insersion estructura con su ejemplo


Resultado de imagen para metodo de insercion en diagrama estructura


Método de Inserción


Método de Inserción Este método también se denomina “método del jugador de cartas”, por la semejanza con la forma de clasificar las cartas de una baraja, insertando cada carta en el lugar adecuado. El algoritmo ordena los dos primeros elementos de la lista, a continuación el tercer elemento se inserta en la posición que corresponda, el cuarto se inserta en la lista de tres elementos, y así sucesivamente. Este proceso continua hasta que la lista este totalmente ordenada. Sea una lista A[1], A[2], ... A[n]. Los pasos a dar para una ordenación ascendente son: 1. Ordenar A[1] y A[2]. 2. Comparar A[3] con A[2], si A[3] es mayor o igual a que A[2], sigue con el siguiente elemento si no se compara A[3] con A[1]; si A[3] es mayor o igual que A[1], insertar A[3] entre A[1] yA[2]. Si A[3] es menor que A[1], entonces transferir A[3] a A[1], A[1] a A[2] y A[2] a A[3]. 3. Se suponen ordenados los n-1 primeros elementos y corresponde insertar el n-ésimo elemento. Si A[m] es mayor que A[k] (con K = 1, 2, ..., m-1), se debe correr una posición A[k+1], ... A[m-1] y almacenar A[m] en la posición k+1.



Consideremos el mismo arreglo del ejemplo anterior { 7, 2, 8, 3, 5, 1 }. El proceso sería de la siguiente manera: 

1ra iteración, i permanece fijo en la casilla 1 y j se decrementa mientras el elemento es menor a j: { 7, 2, 8, 3, 5, 1 } tem = 2, j = 0, mientras j >= 0 y tem < 7, { 7, 7, 8, 3, 5, 1 }, j se decrementa en 1 { 7, 7, 8, 3, 5, 1 } tem = 2, j = -1, mientras j >=0, rompe mientras, tem ingresa { 2, 7, 8, 3, 5, 1 } 

2da iteración, i permanece fijo en la casilla 2 y j se decrementa mientras el elemento es menor a j: { 2, 7, 8, 3, 5, 1 } tem = 8, j = 1, mientras j >= 0 y tem < 7, rompe mientras { 2, 7, 8, 3, 5, 1 } 

3ra iteración, i permanece fijo en la casilla 3 y j se decrementa mientras el elemento es menor a j: { 2, 7, 8, 3, 5, 1 } tem = 3, j = 2, mientras j >= 0 y tem < 8, { 2, 7, 8, 8, 5, 1 }, j se decrementa en 1 { 2, 7, 8, 8, 5, 1 } tem = 3, j = 1, mientras j >= 0 y tem < 7, { 2, 7, 7, 8, 5, 1 }, j se decrementa en 1 { 2, 7, 7, 8, 5, 1 } tem = 3, j = 0, mientras j >= 0 y tem < 2, rompe, tem ingresa { 2, 3, 7, 8, 5, 1 }

 4ta iteración, i permanece fijo en la casilla 4 y j se decrementa mientras el elemento es menor a j: { 2, 3, 7, 8, 5, 1 } tem = 5, j = 3, mientras j >= 0 y tem < 8, { 2, 3, 7, 8, 8, 1 }, j se decrementa en 1 { 2, 3, 7, 8, 8, 1 } tem = 5, j = 2, mientras j >= 0 y tem < 7, { 2, 3, 7, 7, 8, 1 }, j se decrementa en 1 { 2, 3, 7, 7, 8, 1 } tem = 5, j = 1, mientras j >= 0 y tem < 3, rompe, tem ingresa { 2, 3, 5, 7, 8, 1 }

 5ta iteración, i permanece fijo en la casilla 5 y j se decrementa mientras el elemento es menor a j: { 2, 3, 5, 7, 8, 1 } tem = 1, j = 4, mientras j >= 0 y tem < 8, { 2, 3, 5, 7, 8, 8 }, j se decrementa en 1 { 2, 3, 5, 7, 8, 8 } tem = 1, j = 3, mientras j >= 0 y tem < 7, { 2, 3, 5, 7, 7, 8 }, j se decrementa en 1

{ 2, 3, 5, 7, 7, 8 } tem = 1, j = 2, mientras j >= 0 y tem < 5, { 2, 3, 5, 5, 7, 8 }, j se decrementa en 1
 { 2, 3, 5, 5, 7, 8 } tem = 1, j = 1, mientras j >= 0 y tem < 3, { 2, 3, 3, 5, 7, 8 }, j se decrementa en 1 
{ 2, 3, 3, 5, 7, 8 } tem = 1, j = 0, mientras j >= 0 y tem < 2, { 2, 2, 3, 5, 7, 8 }, j se decrementa en 1
 { 2, 2, 3, 5, 7, 8 } tem = 1, j = -1, mientras j >= 0, rompe mientras, tem ingresa { 1, 2, 3, 5, 7, 8 }   

 Diagrama de flujo de ordenamiento por inserción



jueves, 5 de enero de 2017

diagrama de flujo : el area de un triangulo por for


METODO BURBUJA


ORDENAMIENTO POR SELECCIÓN

ORDENAMIENTO POR SELECCION  
El ordenamiento por selección (Selection Sort en inglés) es un algoritmo de ordenamiento que requiere O(n^2) operaciones para ordenar una lista de n elementos.
Su funcionamiento es el siguiente:

  • Buscar el mínimo elemento de la lista
  • Intercambiarlo con el primero
  • Buscar el mínimo en el resto de la lista
  • Intercambiarlo con el segundo
Y en general:

  • Buscar el mínimo elemento entre una posición i y el final de la lista
  • Intercambiar el mínimo con el elemento de la posición i
De esta manera se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:
para i=1 hasta n-1
    minimo = i;
    para j=i+1 hasta n
        si lista[j] < lista[minimo] entonces
            minimo = j /* (!) */
        fin si
    fin para
    intercambiar(lista[i], lista[minimo])
fin para 
 
 

 
seleccion 
#include<stdio.h> 
#include<conio.h> 
int x[4]={1,4,8,6}; 
int n=4,j=0,i=0; 
int temp=0,minimo=0; 
void main(){ 
clrscr(); 
for(i=0;i<n-1;i++) 

minimo=i; 
for(j=i+1;j<n;j++) 

if(x[minimo] > x[j]) 

minimo=j; 


temp=x[minimo]; 
x[minimo]=x;
x=temp;
}
for(i=0;i<n;i++)
{
printf("%d",x);
}
getch();
}
EJERCICIOS METODO DE ORDENAMIENTO EJERCICIO 01
#include <stdio.h>
#define SIZE 7
void main(void) {
  int vector[SIZE];
  int j, i, temp;
  printf("Introduce los %d valores para ordenar:\n", SIZE);
  for(i=0; i<SIZE; i++) {
     printf("%d: ", i+1);
     scanf("%d", &vector[i]);
     printf("\n");
  }
  /* se aplica el algoritmo de la burbuja */
  for(i=0; i<(SIZE-1); i++) {
     for (j=i+1; j<SIZE; j++) {
        if(vector[j]<vector[i]) {
            temp=vector[j];
            vector[j]=vector[i];
            vector[i]=temp;
        }
     }
  }
  printf("El vector ordenado es:\n");
  for(i=0; i<SIZE ; i++) {
     printf("%d ", vector[i]);
  }
  printf("\n");
}
 
EJERCIO 02
 
#include <stdio.h>

#include <stdlib.h>

#include <string.h>
 

void OrdenaBurbuja (float v[], int n)

{

int t, h, e;

for (h=1; h<n; h++)

{

for(e=0; e<n;e++)

{

if (v[e]>v[e+1])

{

v[e+1] = t;

v[e] = v[e+1];

t= v[e];

}

}

}

}
 
 

void ImprimirVector(float v[], int n)

{

int i; 

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

{

printf("%f ", v[i]);

}

}
 

int main(int argc, char *argv[])

{

if(strcmp(argv[1], "burbuja")==0)

{

int n, i, m=2, o;

float *v;

{

n=argc-2; 

v =(float *)malloc(n*sizeof(float));

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

{

v[i] = atof(argv[i+2]);

}

}

OrdenaBurbuja(v, n);

ImprimirVector(v, n);

}

system("PAUSE"); 

return 0;

}

ORDENAMIENTO POR INSERCIÓN

ORDENAMIENTO POR INSERCION  
El ordenamiento por inserción (insertion sort en inglés) es una manera muy natural de ordenar para un ser humano, y puede usarse fácilmente para ordenar un mazo de cartas numeradas en forma arbitraria. Requiere O(n²) operaciones para ordenar una lista de n elementos.

Inicialmente se tiene un solo elemento, que obviamente es un conjunto ordenado. Después, cuando hay k elementos ordenados de menor a mayor, se toma el elemento k+1 y se compara con todos los elementos ya ordenados, deteniéndose cuando se encuentra un elemento menor (todos los elementos mayores han sido desplazados una posición a la derecha) o cuando ya no se encuentran elementos (todos los elementos fueron desplazados y este es el más pequeño). En este punto se inserta el elemento k+1 debiendo desplazarse los demás elementos.





iinserccion
#include<stdio.h>
#include<conio.h>
int a[4]={4,1,7,2};
int n=4;
int i,j,aux;
void main(){
clrscr();
for(i=1;i<n;i++)
{
j=i;
aux=a;
while(j>0 && aux<a[j-1])
{
a[j]=a[j-1];
j--;
}
a[j]=aux;
}
for(i=0;i<4;i++)
{
printf("%d",a);
}
getch();

ORDENAMIENTO SHELL




ORDENAMIENTO SHELL El ordenamiento Shell (Shell sort en inglés) es un algoritmo de ordenamiento. El método se denomina Shell en honor de su inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso. Un cambio menor presentado en el libro de V. Pratt produce una implementación con un rendimiento de O(n log2 n) en el peor caso. Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n). Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución. El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos separados por un espacio de varias posiciones. Esto permite que un elemento haga "pasos más grandes" hacia su posición esperada. Los pasos múltiples sobre los datos se hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort es un simple ordenamiento por inserción, pero para entonces, ya está garantizado que los datos del vector están casi ordenados.  


#include<stdio.h>
#include<conio.h>
int a[5];
int n=5;
void main()
{
int inter=(n/2),i=0,j=0,k=0,aux;
clrscr();
for (i=0; i<5; i++)
{
printf("INSERTA UN VALOR DEL INDICE %d", i);
scanf("%d",& a);
}
while(inter>0){
for(i=inter;i<n;i++)
{
j=i-inter;
while(j>=0) {
k=j+inter;
if(a[j]<=a[k]){
j--;
}
else{
aux=a[j];
a[j]=a[k];
a[k]=aux;
j=j-inter;
}
}
}
inter=inter/2;
}
for(i=0;i<5;i++)
{
printf("%d n",a);
getch();
}
}  
 


Resultado de imagen para imagenes sobre ordenamiento shell