Ejercicios y prácticas resueltas de programación en lenguaje C ( 40 )

Prácticas y Ejercicios con Solución

Ejercicios, Prácticas, Cursos Gratuitos

Ejercicios : Métodos de ordenación con un vector numérico

Método de ordenación por inserción directa, burbuja o hundimiento

Método de ordenación por selección directa

Ejercicios con solución y prácticas resueltas de programación en c,nuevos ejercicios de programación en lenguaje C. El enunciado de las prácticas y ejercicios que se plantea es el siguiente.

Los ejercicios y prácticas propuestos son de una nueva serie dedicada a la programación en c, con prácticas que se realizan  en la universidad, en este caso se tratan de prácticas de programación en c que solicitan un vector numérico como entrada de datos, y utilizando funciones realiza la ordenación del vector mediante dos métodos sencillos para ordenar vectores.

Vuelvo a comentar que no es la única solución posible y que la forma de mejorar siempre estas prácticas es que aportéis vuestro granito de arena utilizando para ello los comentarios. Un saludo y gracias por vuestra visita.

Para realizar las practicas o consultar los ejercicios de programación resueltos has de pulsar sobre el enlace a continuación denominado “LEER EL ARTICULO COMPLETO”. Recuerda también darnos ánimos haciendo un clic en el botón google+1 de la columna izquierda o el que esta situado en la parte superior del articulo, así como recomendar la visita a nuestra página a tus amigos.

Recordaros que los cursos online gratuitos en modalidad a distancia o teleformación, no pretenden ser un temario cerrado y que esperamos vuestras aportaciones. Muchísimas gracias por visitarnos.

Ejercicios y practicas de programación en c resueltos o con solución

El ejercicio planteado es el siguiente:

Ejercicios : Métodos de ordenación con un vector numérico

Método de ordenación por inserción directa, burbuja o hundimiento

Método de ordenación por selección directa

Ejercicios y Practicas resueltas en lenguaje de programación en lenguaje C, Cursos Online Gratuitos

se plantea realizar una lista de enlace simple con punteros, la cual permita la inserción, eliminación y listado de los elementos de la lista, no es la única forma de realizar el ejercicio, ni quizás sea la mas adecuada según los planteamientos de estructuras de datos, pero es fácilmente adaptable y comprensible para su modificación.  La solución de los ejercicios que se plantean es la siguiente:

/*

  Métodos de ordenación de vectores

  ==================================

  Ordenación por intercambio directo (Burbuja o Hundimiento)

  Ordenación por selección directa

  Los ejercicios y practicas propuestos permiten realizar la ordenación de un vector numerico
mediante los métodos de ordenación por selección y por el metodo denominado normalmente burbuja.
Los ejercicios están propuestos por un alumno, que espero pueda consultar los ejercicios y practicas
para su resolución de una manera más efectiva.

*/

#define MAX 10

// Librerías a utilizar

#include <stdio.h>

#include <stdlib.h>

// Predefinición de funciones

void Pide_Datos_Vector(int []);

void Visualiza_Datos_Vector(int []);

void Ordenar_Intercambio_Directo(int [],int []);

void Ordenar_Seleccion_Directa(int [],int []);

// Función principal

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

{

    // Definicion de variables a utilizar

    int VectorDesordenado[MAX];

    int VectorOrdenado[MAX];

    int Opcion=0;

    // Inicializar los vectores para evitar posibles errores

    for(Opcion=0;Opcion<MAX;Opcion++)

    {

      VectorDesordenado[Opcion] = 0;

      VectorOrdenado[Opcion] = 0;

    }

    // Visualizar menú de opciones

    do {

       printf("\n1.- Solicitar datos del vector.");

       printf("\n2.- Visualizar datos del vector desordenado.");

       printf("\n3.- Ordenar por intercambio directo.");

       printf("\n4.- Ordenar por seleccion directa.");

       printf("\n5.- Visualizar datos del vector ordenado.");

       printf("\n6.- Rellenar vector desordenado aleatoriamente.");

       printf("\n0.- Salir");

       printf("\n=============================================");

       printf("\nOpcion...: ");

       scanf(" %d",&Opcion);

       switch(Opcion) {

         case 1:

              // Solicitar datos del vector, llamar a la funcion pedir

              Pide_Datos_Vector(VectorDesordenado);

              break;

         case 2:

              // Visualizar datos del vector desordenado

              Visualiza_Datos_Vector(VectorDesordenado);

              break;

         case 3:

              // Ordenar por el metodo de intercambio directo

              Ordenar_Intercambio_Directo(VectorDesordenado,VectorOrdenado);

              break;

         case 4:

              // Ordenar por el metodo de seleccion directa

              Ordenar_Seleccion_Directa(VectorDesordenado,VectorOrdenado);

              break;

         case 5:

              // Visualizar datos del vector ordenado

              Visualiza_Datos_Vector(VectorOrdenado);

              break;

       }

    } while(Opcion!=0);  

  system("PAUSE");	

  return 0;

}

// Función Solicitar Datos del vector desordenado

void Pide_Datos_Vector(int VectorDesordenado[])

{

     // Crear variable contador para recorrer el vector

     int contador=0;

     // Recorrer el vector y solicitar datos del mismo

     for(contador=0;contador<MAX;contador++)

     {

      printf("\nValor posicion [%d] : ",contador+1);

      scanf(" %d",&VectorDesordenado[contador]);

     }

}

// Función para visualizar los datos del vector desordenado/ordenado

void Visualiza_Datos_Vector(int Vector[])

{

     // Crear variable contador para recorrer el vector

     int contador=0;

     // Recorrer el vector y visualizar los datos del mismo

     printf("\n========================================================\n\n");

     for(contador=0;contador<MAX;contador++)

     {

       printf("%5d",Vector[contador]);

     }

     printf("\n\n========================================================\n");

}

// Función para ordenar el vector con el método de intercambio directo

void Ordenar_Intercambio_Directo(int VectorD[],int VectorO[])

{

     // Variables para recorrer los vectores

     int contador = 0;

     int elementos = 0;

     int intercambio = 0;

     int bandera = 1;

     // Copiar el contenido del vector desordenado al ordenado

     for(contador=0;contador<MAX;contador++)

     {

        VectorO[contador] = VectorD[contador];

     }

     // Ordenar el vector por el método de la burbuja

     printf("\n\nOrdenando Vector .");

     for(elementos=MAX-1;elementos>0 && bandera==1;elementos--)

     {

       bandera = 0;

       for(contador=0;contador<elementos;contador++)

       {

         if(VectorO[contador]>VectorO[contador+1])

         {

           intercambio = VectorO[contador];

           VectorO[contador] = VectorO[contador+1];

           VectorO[contador+1] = intercambio; 

           bandera = 1;

           printf(".");

         }

       }

     }

     printf("\n\nVector Ordenado\n\n");

}

// Función para ordenar el vector con el método de selección directa

void Ordenar_Seleccion_Directa(int VectorD[],int VectorO[])

{

     // Variables a utilizar

     int minimo = 0;

     int pos_minimo = 0;

     int contador = 0;

     int elementos = 0;

     int intercambio = 0;

     // Copiar el contenido del vector desordenado al ordenado

     for(contador=0;contador<MAX;contador++)

     {

        VectorO[contador] = VectorD[contador];

     }

     // Método de ordenación por selección directa

     for(elementos=0;elementos<MAX;elementos++)

     {

       minimo = VectorO[elementos];

       pos_minimo = elementos;

       for(contador=elementos;contador<MAX;contador++)

       {

         if(minimo>VectorO[contador])

         {

           minimo = VectorO[contador];

           pos_minimo = contador;

         }

       }

       intercambio = VectorO[elementos];

       VectorO[elementos] = minimo;

       VectorO[pos_minimo] = intercambio;

     }

}

El resultado del programa ha de ser similar al que se muestra en la imagen siguiente:

Navegacion Series

Anterior en la serie...Siguiente en la serie...

Filed in: 2012, Cursos, Lenguaje C, Lenguaje C++, practicos, programación, Sistemas, soluciones | Tags: apuntes, Cursos, ejercicios, gratuitos, practicas, programación, solucion, soluciones, temarios