Cserés rendezés

Adott egy adathalmazunk, mondjuk egy tömb. A benne tárolt elemeket sorba szeretnénk rendezni. Ez esetben a legegyszerűbb algoritmus, amit választhatunk, az a cserés rendezés.

Ennek a lényege az, hogy a tömb elemeit egymással összehasonlítjuk. Ha a tömb soron következő eleme nagyobb az utána következőnél, akkor megcseréljük őket. Ahhoz, hogy a tömb rendezett állapotba kerüljön, N elem esetén N*N alkalommal kell lefuttatni a cseréket, ami nem a legjobb, mivel az elemszám növekedésével négyzetesen nő a futási idő.

Egy lehetséges implementáció:

using System;

namespace PeldaAlgoritmusCseresrendez
{
    class Program
    {
        static void TombKiir(int[] tomb)
        {
            foreach (var elem in tomb)
            {
                Console.Write("{0}, ", elem);
            }
            Console.WriteLine();
        }

        public static int[] CseresRendez(int[] bemenet)
        {
            int[] tomb = new int[bemenet.Length];
            Array.Copy(bemenet, tomb, bemenet.Length);
            for (int i = 0; i < tomb.Length; i++)
            {
                for (int j = 0; j < tomb.Length; j++)
                {
                    if (tomb[i] < tomb[j])
                    {
                        var tmp = tomb[i];
                        tomb[i] = tomb[j];
                        tomb[j] = tmp;
                    }
                }
            }
            return tomb;
        }

        static void Main(string[] args)
        {
            var tomb = new int[] { 9, 6, 0, 0, 1, 2, 2, 2, 3, 1, 5, 4, 8, 2, 8, 6 };

            Console.WriteLine("Rendezés előtt:");
            TombKiir(tomb);

            Console.WriteLine("Cserés rendezés:");
            var cseres = CseresRendez(tomb);
            TombKiir(cseres);

            Console.ReadKey();
        }
    }
}

A program kimenete:

Rendezés elott:
9, 6, 0, 0, 1, 2, 2, 2, 3, 1, 5, 4, 8, 2, 8, 6, 
Cserés rendezés:
0, 0, 1, 1, 2, 2, 2, 2, 3, 4, 5, 6, 6, 8, 8, 9,