Método de Ordenamiento de Inserción Binaria en C#

Método de Ordenamiento de Inserción Binaria en C# 

La Inserción Binaria, es una mejora de la Inserción Directa.

La Inserción Binaria es un método de inserción, que difiere de la Inserción Directa simplemente en la búsqueda de la posición de la Inserción.

Veamos un ejemplo de como funciona este método de ordenamiento de Inserción Binaria, analizando paso a paso.

1. Hallamos el elemento central del área comprendida por la parte ordenada más la posición del elemento a insertar.

2. Comparamos el elemento central con el elemento que queremos insertar. Si dicho elemento central es menor o igual, nos quedamos con la parte derecha (Sin incluir el elemento central). En caso contrario, nos quedamos con la parte izquierda incluyendo al elemento central.

3. Repetimos el mismo proceso sobre el área con la que nos quedamos, hasta que dicha área sea nula.

4. Cuando el área sea nula, tendremos la posición de inserción.

A continuación veamos un ejemplo en Pseudo-Código Para el Método de Inserción Binaria

Ejemplo del Código Implementado 

Un ejemplo de método de inserción binaria en C# 

                    int auxiliar;

                    int q;

                    int izqui;

                    int dere;

                    for (int i = 0; i < numeros.Length; i++)

                    {

                        auxiliar = numeros[i];

                        izqui = 0;

                        dere = i - 1;

                        while (izqui <= dere)

                        {

                            q = ((izqui + dere) / 2);

                            if (auxiliar < numeros[q])

                            {

                                dere = q - 1;

                            }

                            else

                            {

                                izqui = q + 1;

                            }

                            j = i - 1;

                            while (j >= izqui)

                            {

                                numeros[j + 1] = numeros[j];

                                j = j - 1;

                            }

                            numeros[izqui] = auxiliar;

                        }

                    }

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

                        Console.WriteLine(" " + numeros[i]);

Ordenamiento por Merge Sort en C#

Método de Ordenamiento Merge Sort  en C#

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace MergeSort

{

    class Program

    {

        static void Main(string[] args)

        {

            int[] nums = new int[40];

            Console.WriteLine("Metodo de Merge Sort");

            Console.Write("Cuantos longitud del vector: ");

            string linea;

            linea = Console.ReadLine();

            int cant;

            cant = int.Parse(linea);

            nums = new int[cant];

            for (int f = 0; f< nums.Length; f++)

            {

                Console.Write("Ingrese elemento " + (f + 1) + ": ");

                linea = Console.ReadLine();

                nums[f] = int.Parse(linea);

            }

            MergeSort(nums);

            Console.WriteLine("Vector Ordenado Ascendentemente");

            for (int i = 0; i< nums.Length; i++)

                Console.Write(nums[i] + " ");

            Console.ReadLine();

        }

        //Método portal que llama al método recursivo inicial

        public static void MergeSort(int[] x)

        {

            MergeSort(x, 0, x.Length - 1);

        }

        static private void MergeSort(int[] x, int desde, int hasta)

        {

            //Condicion de parada

            if (desde == hasta)

                return;

            //Calculo la mitad del array

            int mitad = (desde + hasta) / 2;

            //Voy a ordenar recursivamente la primera mitad

            //y luego la segunda

            MergeSort(x, desde, mitad);

            MergeSort(x, mitad + 1, hasta);

            //Mezclo las dos mitades ordenadas

            int[] aux = Merge(x, desde, mitad, mitad + 1, hasta);

            Array.Copy(aux, 0, x, desde, aux.Length);

        }

        //Método que mezcla las dos mitades ordenadas

        static private int[] Merge(int[] x, int desde1, int hasta1, int desde2, int hasta2)

        {

            int a = desde1;

            int b = desde2;

            int[] result = new int[hasta1 - desde1 + hasta2 - desde2 + 2];

            for (int i = 0; i< result.Length; i++)

            {

                if (b != x.Length)

                {

                    if (a > hasta1 && b <= hasta2)

                    {

                        result[i] = x[b];

                        b++;

                    }

                    if (b > hasta2 && a <= hasta1)

                    {

                        result[i] = x[a];

                        a++;

                    }

                    if (a <= hasta1 && b <= hasta2)

                    {

                        if (x[b] <= x[a])

                        {

                            result[i] = x[b];

                            b++;

                        }

                        else

                        {

                            result[i] = x[a];

                            a++;

                        }

                    }

                }

                else

                {

                    if (a <= hasta1)

                    {

                        result[i] = x[a];

                        a++;

                    }

                }

            }

            return result;

        }

    }

}

Al ejecutar el código muestra el siguiente resultado

Ordenamiento por Shaker Sort en C#

Método de Ordenamiento Shaker Sort en C#

int n = numeros.Length;

            int izq = 1;

            int k = n;

            int aux;

            int der = n;

            do

            {

                for (int i = der; i >= izq; i--)

                {

                    if (numeros[i - 1] > numeros[i])

                    {

                        aux = numeros[i - 1];

                        numeros[i - 1] = numeros[i];

                        numeros[i] = aux;

                        k = i;

                    }

                }

                izq = k + 1;

                for (int i = izq; i <= der; i++)

                {

                    if (numeros[i - 1] > numeros[i])

                    {

                        aux = numeros[i - 1];

                        numeros[i - 1] = numeros[i];

                        numeros[i] = aux;

                        k = 1;

                    }

                }

                der = k - 1;

            }

            while (der >= izq);

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

                Console.WriteLine(" " + numeros[i]);

Ordenamiento por Burbuja en C#

Método de Ordenamiento Burbuja en C#

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Burbuja

{

    class Burbuja

    {

        private int[] vector;

        public void Cargar()

        {

            Console.WriteLine("Metodo de Burbuja");

            Console.Write("Cuantos longitud del vector: ");

            string linea;

            linea = Console.ReadLine();

            int cant;

            cant = int.Parse(linea);

            vector = new int[cant];

            for (int f = 0; f < vector.Length; f++)

            {

                Console.Write("Ingrese elemento "+(f+1)+": ");

                linea = Console.ReadLine();

                vector[f] = int.Parse(linea);

            }

        }

        public void MetodoBurbuja()

        {

            int t;

            for (int a = 1; a< vector.Length; a++)

                for (int b = vector.Length - 1; b >= a; b--)

                {

                    if (vector[b - 1] > vector[b])

                    {

                        t = vector[b - 1];

                        vector[b - 1] = vector[b];

                        vector[b] = t;

                    }

                }

        }

        public void Imprimir()

        {

            Console.WriteLine("Vector ordenados en forma ascendente");

            for (int f = 0; f< vector.Length; f++)

            {

                Console.Write(vector[f]+"  ");

            }

            Console.ReadKey();

        }

        static void Main(string[] args)

        {

            Burbuja pv = new Burbuja();

            pv.Cargar();

            pv.MetodoBurbuja();

            pv.Imprimir();

        }

    }

}

Al ejecutar el código muestra el siguiente resultado

Ordenamiento por Quick Sort en C#

Método de Ordenamiento Quick Sort en C#

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace quicksort

{

    class Class

    {

        static void Main()

        {

            int n;

            Console.WriteLine("Metodo de Quick Sort");

            Console.Write("Cuantos longitud del vector: ");

            n = Int32.Parse(Console.ReadLine());

            llenar b = new llenar(n);

        }

    }

    class llenar

    {

        int h;

        int[] vector;

        public llenar(int n)

        {

            h = n;

            vector = new int[h];

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

            {

                Console.Write("ingrese valor {0}: ", i + 1);

                vector[i] = Int32.Parse(Console.ReadLine());

            }

            quicksort(vector, 0, h - 1);

            mostrar();

        }

        private void quicksort(int[] vector, int primero, int ultimo)

        {

            int i, j, central;

            double pivote;

            central = (primero + ultimo) / 2;

            pivote = vector[central];

            i = primero;

            j = ultimo;

            do

            {

                while (vector[i] < pivote) i++;

                while (vector[j] > pivote) j--;

                if (i <= j)

                {

                    int temp;

                    temp = vector[i];

                    vector[i] = vector[j];

                    vector[j] = temp;

                    i++;

                    j--;

                }

            } while (i <= j);

            if (primero < j)

            {

                quicksort(vector, primero, j);

            }

            if (i < ultimo)

            {

                quicksort(vector, i, ultimo);

            }

        }

        private void mostrar()

        {

            Console.WriteLine("Vector ordenados en forma ascendente");

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

            {

                Console.Write("{0} ", vector[i]);

            }

            Console.ReadLine();

        }

    }

}

Al ejecutar el código muestra el siguiente resultado

Ordenamiento por Shell Sort en C#

Método de Ordenamiento Shell Sort en C#

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace PruebaVector

{

    class PruebaVector

    {

        private int[] vector;

        public void Cargar()

        {

            Console.WriteLine("Metodo de Shell Sort");

            Console.Write("Cuantos longitud del vector:");

            string linea;

            linea = Console.ReadLine();

            int cant;

            cant = int.Parse(linea);

            vector = new int[cant];

            for (int f = 0; f < vector.Length; f++)

            {

                Console.Write("Ingrese elemento "+(f+1)+": ");

                linea = Console.ReadLine();

                vector[f] = int.Parse(linea);

            }

        }

        public void Shell()

        {

            int salto = 0;

            int sw = 0;

            int auxi = 0;

            int e = 0;

            salto = vector.Length / 2;

            while (salto > 0)

            {

                sw = 1;

                while (sw != 0)

                {

                    sw = 0;

                    e = 1;

                    while (e <= (vector.Length - salto))

                    {

                        if (vector[e - 1] > vector[(e - 1) + salto])

                        {

                            auxi = vector[(e - 1) + salto];

                            vector[(e - 1) + salto] = vector[e - 1];

                            vector[(e - 1)] = auxi;

                            sw = 1;

                        }

                        e++;

                    }

                }

                salto = salto / 2;

            }

        }

        public void Imprimir()

        {

            Console.WriteLine("Vector ordenados en forma ascendente");

            for (int f = 0; f < vector.Length; f++)

            {

                Console.Write(vector[f]+"  ");

            }

            Console.ReadKey();

        }

        static void Main(string[] args)

        {

            PruebaVector pv = new PruebaVector();

            pv.Cargar();

            pv.Shell();

            pv.Imprimir();

        }

    }

}

Al ejecutar el código muestra el siguiente resultado