Wyszukiwanie i sortowanie — krok po kroku

int[] dane = { 42, 17, 93, 8, 55, 23 };
int szukana = 55;

int znaleziono = -1;
int porownan = 0;

for (int i = 0; i < dane.Length; i++)
{
    porownan++;

    if (dane[i] == szukana)
    {
        znaleziono = i;
        break;                  // dalej szukac nie ma po co
    }
}

if (znaleziono >= 0)
{
    Console.WriteLine($"Znaleziono na indeksie {znaleziono} po {porownan} porownaniach.");
}
else
{
    Console.WriteLine($"Nie znaleziono. Sprawdzono {porownan} elementow.");
}

int[] dane = { 3, 8, 12, 17, 23, 31, 42, 56, 68, 74, 89, 95 };   // POSORTOWANE
int szukana = 56;

int lewy = 0;
int prawy = dane.Length - 1;
int znaleziono = -1;
int krok = 0;

while (lewy <= prawy)
{
    krok++;
    int srodek = (lewy + prawy) / 2;

    Console.WriteLine($"krok {krok}: lewy={lewy} srodek={srodek} prawy={prawy} " +
                      $"-> dane[{srodek}]={dane[srodek]}");

    if (dane[srodek] == szukana)
    {
        znaleziono = srodek;
        break;
    }
    else if (dane[srodek] < szukana)
    {
        lewy = srodek + 1;          // szukana jest w prawej polowie
    }
    else
    {
        prawy = srodek - 1;         // szukana jest w lewej polowie
    }
}

Console.WriteLine();
Console.WriteLine(znaleziono >= 0
    ? $"Znaleziono na indeksie {znaleziono} w {krok} krokach."
    : $"Nie znaleziono ({krok} krokow).");

int[] t = { 10, 20 };

// TAK NIE - obie komorki beda mialy 20
// t[0] = t[1];
// t[1] = t[0];

// poprawnie: przez zmienna pomocnicza
int pomocnicza = t[0];
t[0] = t[1];
t[1] = pomocnicza;

Console.WriteLine(string.Join(", ", t));

// krocej, od C# 7 - krotka
(t[0], t[1]) = (t[1], t[0]);
Console.WriteLine(string.Join(", ", t));

int[] t = { 5, 2, 9, 1, 7, 3 };
int n = t.Length;

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

    for (int j = 0; j < n - 1 - i; j++)      // uwaga na "- i"
    {
        if (t[j] > t[j + 1])
        {
            int pom = t[j];
            t[j] = t[j + 1];
            t[j + 1] = pom;
            zamian++;
        }
    }

    Console.WriteLine($"przebieg {i + 1}: {string.Join(", ", t)}  (zamian: {zamian})");

    if (zamian == 0)
    {
        break;                    // juz posortowane - nie ma po co isc dalej
    }
}

int[] t = { 5, 2, 9, 1, 7, 3 };
int n = t.Length;

for (int i = 0; i < n - 1; i++)
{
    // szukamy INDEKSU najmniejszego w czesci od i do konca
    int indeksMin = i;

    for (int j = i + 1; j < n; j++)
    {
        if (t[j] < t[indeksMin])
        {
            indeksMin = j;
        }
    }

    // zamiana - tylko jesli trzeba
    if (indeksMin != i)
    {
        int pom = t[i];
        t[i] = t[indeksMin];
        t[indeksMin] = pom;
    }

    Console.WriteLine($"krok {i + 1}: {string.Join(", ", t)}");
}

int[] t = { 5, 2, 9, 1, 7, 3 };
int n = t.Length;

for (int i = 1; i < n; i++)          // start od 1: element 0 to juz "posortowana czesc"
{
    int klucz = t[i];                // element, ktory wstawiamy
    int j = i - 1;

    // przesuwamy w prawo wszystko, co jest wieksze od klucza
    while (j >= 0 && t[j] > klucz)
    {
        t[j + 1] = t[j];
        j--;
    }

    t[j + 1] = klucz;                // tu jest jego miejsce

    Console.WriteLine($"krok {i}: {string.Join(", ", t)}");
}

const int Ile = 20;

Random los = new Random(42);          // stale ziarno - te same dane przy kazdym uruchomieniu
int[] oryginal = new int[Ile];

for (int i = 0; i < Ile; i++)
{
    oryginal[i] = los.Next(1, 100);
}

Console.WriteLine($"Dane: {string.Join(", ", oryginal)}");
Console.WriteLine();
Console.WriteLine($"{"Algorytm",-24}{"Porownan",10}{"Zamian",10}");
Console.WriteLine(new string('-', 44));

// --- 1. babelkowe ---
int[] a = oryginal[..];
int por = 0, zam = 0;

for (int i = 0; i < a.Length - 1; i++)
{
    bool bylaZamiana = false;

    for (int j = 0; j < a.Length - 1 - i; j++)
    {
        por++;

        if (a[j] > a[j + 1])
        {
            int pom = a[j];
            a[j] = a[j + 1];
            a[j + 1] = pom;
            zam++;
            bylaZamiana = true;
        }
    }

    if (!bylaZamiana)
    {
        break;
    }
}

Console.WriteLine($"{"babelkowe",-24}{por,10}{zam,10}");

// --- 2. przez wybor ---
int[] b = oryginal[..];
por = 0;
zam = 0;

for (int i = 0; i < b.Length - 1; i++)
{
    int indeksMin = i;

    for (int j = i + 1; j < b.Length; j++)
    {
        por++;

        if (b[j] < b[indeksMin])
        {
            indeksMin = j;
        }
    }

    if (indeksMin != i)
    {
        int pom = b[i];
        b[i] = b[indeksMin];
        b[indeksMin] = pom;
        zam++;
    }
}

Console.WriteLine($"{"przez wybor",-24}{por,10}{zam,10}");

// --- 3. przez wstawianie ---
int[] c = oryginal[..];
por = 0;
zam = 0;

for (int i = 1; i < c.Length; i++)
{
    int klucz = c[i];
    int j = i - 1;

    while (j >= 0)
    {
        por++;

        if (c[j] <= klucz)
        {
            break;
        }

        c[j + 1] = c[j];
        zam++;
        j--;
    }

    c[j + 1] = klucz;
}

Console.WriteLine($"{"przez wstawianie",-24}{por,10}{zam,10}");
Console.WriteLine(new string('-', 44));

// --- sprawdzenie, czy wszystkie daly ten sam wynik ---
Console.WriteLine();
Console.WriteLine($"Wynik:  {string.Join(", ", a)}");
Console.WriteLine($"Zgodne: {a.SequenceEqual(b) && b.SequenceEqual(c)}");