Mierzenie czasu sortowania tablicy

Witam,
mam za zadanie zmierzyc czas sortowania dla losowych tablic o elementach:
1·10^{3, 2·10}3, 3·10^{3, 4·10}3, 5·10^{3, 6·10}3, z wielka męka napisalem kod sortujacy:
Teraz pozostaje mi zmierzenie czasu, ktory program spedzi na sortowaniu danej tablicy, szczerze mowiac nie wiem jak sie za to zabrac i bylbym mega wdzieczny gdyby ktos zechcial mi w tym pomoc:)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication6
{
    class Program
    {
        public static void Main(string[] args)
        {

            int i;


            Random Generator;
            Generator = new Random();
            int[] tablica = new int[1000000];
            for (i = 0; i < tablica.Length; i++)
            {
                tablica[i] = Generator.Next(5000);
            }
            Console.WriteLine("Tablica:");
            for (i = 0; i < tablica.Length; i++)
            {
                Console.WriteLine("Elem." + tablica[i]);
            }
            Console.WriteLine("Po sortowaniu bąbelkowym");
            Program.bab(tablica);
            for (i = 0; i < tablica.Length; i++)
            {
                Console.WriteLine("Elem:" + tablica[i]);

            }
            
            Console.ReadKey();
        }
        static void bab(int[] tablica)
        {
            int buf;
            
            for (int j = 0; j < tablica.Length - 1; j++)
            {
                
                if (tablica[j] > tablica[j + 1])
                {
                    
                    buf = tablica[j];
                    
                    tablica[j] = tablica[j + 1];
                    
                    tablica[j + 1] = buf;
                    
                    j = -1;

                }


            }
        }

       
    }
} 

http://stackoverflow.com/questions/4016483/c-sharp-get-time-in-milliseconds

Też ostatnio było poruszane w tym wątku:
C# Sortowanie liczb

Zmotalem cos takiego:

Poczatek kodu-----

for (i = 0; i < tablica.Length; i++)
            {
                Console.WriteLine("Elem:" + tablica[i]);
 
            }
 
string s;
            while ((s = Console.ReadLine()) != null)
            {
                int n = int.Parse(s);
                for (int repeat = 0; repeat < 5; ++repeat)
                {

                    DateTime timer = DateTime.Now;
                    Stopwatch sw = new Stopwatch();
                    sw.Reset();
                    sw.Start();
                    Program.bab(tablica);
                    
                    sw.Stop();
                    double nanoseconds = 1e9 * sw.ElapsedTicks / Stopwatch.Frequency;
                    Console.WriteLine("{0,8}:{1}: Średnia={2:F6} czas operacji={3}ns", n,
                    i + 1,
                    nanoseconds);
tutaj jest funkcja bab.
                }

jednak poza sortowaniem nie wyswietla mi niestety czasu operacji, dodatkowo cala tablica sortuje sie, jednak jezeli wezme elementy tablicy powyzej 1 miliona juz tego niestety nie robi, zmiana int na long bylaby rozwiazaniem czy jednak trzeba cos wiecej zrobic?

Bardzo prosze i dziekuje za pomoc!:P

Tak na oko to w:

Console.WriteLine("{0,8}:{1}: Średnia={2:F6} czas operacji={3}ns", n, i + 1, nanoseconds);

Chcesz wyświetlić 4 argumenty a masz tylko 3 to się nawet nie skompiluje zadziała przynajmniej tak mi się wydaje.

Co do tablicy to nie wiem powinno działać tak samo dla 100 jak i 1mln ale pokaż więcej kodu łatwiej będzie ogarnąć albo cały projekt. :P

A tak w ogóle to nie podaje Ci nanosekund:
double nanoseconds = 1e9 * sw.ElapsedTicks / Stopwatch.Frequency;

Niby sie wlasnie kompiluje ale w ogole czasu itd nie wyswietla,
Her u are my dear:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Threading;

namespace ConsoleApplication6
{
    class Program
    {
        public static void Main(string[] args)
        {

            long i;
            Stopwatch stopwatch = new Stopwatch();
            long seed = Environment.TickCount;
           

            Random Generator;
            Generator = new Random();
            int[] tablica = new int[100];
            for (i = 0; i < tablica.Length; i++)
            {
                tablica[i] = Generator.Next(100);
            }
            Console.WriteLine("Tablica:");
            for (i = 0; i < tablica.Length; i++)
            {
                Console.WriteLine("Elem." + tablica[i]);
            }
            Console.WriteLine("Po sortowaniu bąbelkowym");
            Program.bab(tablica);
            for (i = 0; i < tablica.Length; i++)
            {
                Console.WriteLine("Elem:" + tablica[i]);

            }
            string s;
            while ((s = Console.ReadLine()) != null)
            {
                int n = int.Parse(s);
                for (int repeat = 0; repeat < 5; ++repeat)
                {

                    DateTime timer = DateTime.Now;
                    Stopwatch sw = new Stopwatch();
                    sw.Reset();
                    sw.Start();
                    Program.bab(tablica);
                    
                    sw.Stop();
                    double nanoseconds = 1e9 * sw.ElapsedTicks / Stopwatch.Frequency;
                    Console.WriteLine("{0,8}:{1}: Średnia={2:F6} czas operacji={3}ns", n,
                    repeat + 1, nanoseconds);
                }
                Console.ReadKey();
            }
        }
        static void bab(int[] tablica)
        {
            
            
            int buf;
            
            
            for (int j = 0; j < tablica.Length - 1; j++)
            {

                if (tablica[j] > tablica[j + 1])
                {

                    buf = tablica[j];

                    tablica[j] = tablica[j + 1];

                    tablica[j + 1] = buf;

                    j = -1;

                }


            }
            
        }
            
        }


    }

Może Ci nie wyświetla bo zapomniałeś że w tym momencie program czeka aż podasz jakąś liczbę? i jej nie podajesz:

while ((s = Console.ReadLine()) != null)

I jak ją podasz i dojdzie do w/w Console.WriteLine itd. to wywali ci błąd masz za mało argumentów.

EDIT:

Co do tablicy z 1mln działa nie zawiesza się tylko trwa to strasznie długo nie ma co się dziwić. Poza tym jak nie wierzysz dodaj sobie do funkcji:

tatic void bab(int[] tablica)
        {
            int buf;
            for (int j = 0; j < tablica.Length - 1; j++)
            {
                if (tablica[j] > tablica[j + 1])
                {
                    buf = tablica[j];
                    Console.WriteLine(j); // jakiegos WriteLinei zobaczysz ze cały czas pracuje ;)
// coś tam dalej..

aha to spoczko, tylko dalej tego pomiaru nie mam pomyslu jak zrobic:( jakbys mogl mi cos jakos dopomoc bylbym mega wdzieczny;>

Najprościej:

static void bab(int[] tablica)
        {

            Stopwatch time = new Stopwatch();
            time.Start();
            
            // Sortowanie

            time.Stop();
            Console.WriteLine(time.Elapsed);

 
        }

no w sumie dziala xD mam nadzieje ze kiedys to sie posortuje xD,jak cos to bede pisal, dzieki misiek!!!:)

6milionow sortowalo mi 10 godzin i nie posortowalo, wiec ja juz nie wiem jak mam obliczyc ten czas xD
dodatkowo po sortowaniu 5 tysiecy losowych liczb program wykazuje iz sortowaly sie ponizej sekundy, wiec nie wiem co o tym myslec;/

Jeśli w trakcie sortowania wołasz Console.WriteLine, to przestań, bo to znacznie spowalnia.

I jeszcze takie dwie ciekawostki.

Zamiast:

sw.Reset();
sw.Start();

Można:

sw.Restart();

A zamiast:

Stopwatch sw = new Stopwatch();
sw.Start();

Można:

Stopwatch sw = Stopwatch.StartNew();

ja rozumiem, wyrzucilem wiec fukncji ktora wypisuje na tablicy sortowanie, pozmienialem jak napisales wyzej, jednak i tak mi to sortuje mega dlugo, samo 3 tysiace elementow mi sortuje okolo 1 minuty okolo, wiec jakim cudem mam obliczyc 6 milionow?

Dodatkowo dla 3 tysiecy ogolnie schodzi mi okolo 1 minute, jednak czas wypisywany o wiele krotszy:
0000.0000949
0000.00001024
0000.0000947
0000.0000947
0000.0000947

Dla sortowania przez wybieranie okolo 2x dluzszy, wiec nie dosc ze sortuje mi mega dlugo to jeszcze czasy sortowania zle mi wypisuje;/

ogólnie wypełnienie tablicy 6 milionami elementów i posortowanie jej quicksortem zajmuje niezauważalny ułamek sekundy
bąbelkowe będzie dużo wolniejsze, ale raczej nie będzie to trwać 10 godzin

pokaż swój kod w całości
najlepiej spakuj cały projekt w zipa i dodaj jako załącznik

// edit:
sortowanie bąbelkowe w javascript(!) bez żadnej optymalizacji 1000000 elementów trwało 63 minuty (obciążony tylko jeden wątek procesora)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace ConsoleApplication6
{
    class Program
    {
        public static void Main(string[] args)
        {

            int i;


            //Klasa random
            Random Generator;
            Generator = new Random();
            int[] tablica = new int[10000];//Wypełniam tablice elementami
            for (i = 0; i < tablica.Length; i++)//pętla odnoszaca sie do przedziału losujacych sie w tablicy liczb
            {
                tablica[i] = Generator.Next(100);
            }
            Console.WriteLine("Tablica:");
            for (i = 0; i < tablica.Length; i++)//Nadawanie tablicy elementów.
            {
                Console.WriteLine(i + ".Nr:" + tablica[i]);
            }
            Console.WriteLine("Po sortowaniu bąbelkowym");
            Program.bab(tablica);//wywołanie funkcji bab
            for (i = 0; i < tablica.Length; i++)//pętla wywołujaca tablice po sortowaniu
            {
                Console.WriteLine(i + ".Nr:" + tablica[i]);

            }
            Console.WriteLine("Po sortowaniu po wybieraniu");
            Program.wyb(tablica);//wywołanie funkcji wyb
            for (i = 0; i < tablica.Length; i++)//pętla wywołujaca tablice po sortowaniu
            {
                Console.WriteLine(i + ".Nr:" + tablica[i]);

            }
            Console.WriteLine("Czas dla sortowania bąbelkowego wynosi:");
            Program.czas(tablica);
            Console.WriteLine("Czas dla sortowania przez wybieranie wynosi:");
            Program.czas_2(tablica);

            Console.ReadKey();
        }
        static void czas_2(int[] tablica)//pomiar czasu dla sortowania przez wybieranie
        {
            for (int i = 0; i < 5; i++)
            {

                Stopwatch sw = Stopwatch.StartNew();//pomiar czasu sortowania tablicy
                sw.Restart();
                Program.wyb(tablica);
                sw.Stop();// zatrzymanie pomiaru

                Console.WriteLine(sw.Elapsed);//wypisanie pomiaru

            }
        }
        static void czas(int[] tablica)//pomiar czasu dla sortowania bąbelkowego
        {
            for (int i = 0; i < 5; i++)
            {

                Stopwatch sw = Stopwatch.StartNew();//pomiar czasu sortowania tablicy
                sw.Restart();
                Program.bab(tablica);
                sw.Stop();// zatrzymanie pomiaru

                Console.WriteLine(sw.Elapsed);//wypisanie pomiaru

            }
        }

        static void bab(int[] tablica)
        {
            for (int i = 0; i < 5; i++)//petla wywolujaca pomiar 5x
            {

                int buf;
                //Algorytm sortowania bąbelkowego
                //Ilość elementów musi być mniejsza o 1 od wielkości tablicy
                for (int j = 0; j < tablica.Length - 1; j++)
                {
                    //Jeżeli element tablic jest większy od następnego
                    if (tablica[j] > tablica[j + 1])
                    {
                        //Przypisz do zmiennej pomocniczej wartośc elementu tablicy
                        buf = tablica[j];
                        //Przypisz do tablicy  element o 1 większy
                        tablica[j] = tablica[j + 1];
                        //Przypisz do elementu tablicy o 1 większego wartość zmiennej pomocniczej
                        tablica[j + 1] = buf;
                        //Ustaw pętle for na 0
                        j = -1;

                    }


                }

            }
        }

        static void wyb(int[] tablica)
        {


            int buf;
            //Algorytm sortowania przez wybieranie
            //Ilość elementów musi być mniejsza o 1 od wielkości tablicy
            for (int j = 0; j < tablica.Length - 1; j++)
            {
                //ustaw licznik drugiej liczby na 1. nieposortowaną liczbę
                for (int k = j; k < tablica.Length - 1; k++)
                {
                    //Jeżeli element nieposortowany jest mniejszy to zamień wartości
                    if (tablica[k + 1] < tablica[j])
                    {
                        //Przypisz do zmiennej pomocniczej wartośc elementu tablicy psortowanej                           
                        buf = tablica[j];
                        //Przypisz do tablicy posorotwanej element nieposortowany      
                        tablica[j] = tablica[k + 1];
                        //Przypisz do elementu tablicy nieposortowanej wartość zmiennej pomocniczej
                        tablica[k + 1] = buf;


                    }


                }

            }

        }
    }
}

Sortowanie babelkowe zajmuje mi wlasnie tyle okolo 1/10 sekundy, jednak przez wybieranie masakrycznie dlugo sie robi przykladowo 50tysiecy elementow 8sekund.

Sortowanie bąbelkowe nie zajmuję Ci 1/10 sek, to że sobie wypisujesz taka informację przed sortowanie to nie znaczy że tyle trwa :)

Poprawiłem nieco kolejność. Test dla 1000 elementów
Czas dla sortowania bąbelkowego wynosi:
0000.7929882 <=== zwróć uwagę, tak naprawdę ten wynik tylko się liczy
0000.0000463 <=== W przypadku posortowanej już wcześniej to jest praktycznie przeiterowanie po tablicy
0000.0000488
0000.0000455
0000.0000368
Czas dla sortowania przez wybieranie wynosi:
0000.0030235
0000.0029174
0000.0029199
0000.0028967
0000.0029190
więc chwilę :)

Dalej masz dwa sortowania bąbelkowe, wybieranie, bąbel, wybieranie, wybieranie z tego co pamietam ma złożoność On^2 czyli dla np 100 elementów będzie to 100*100 operacji.
W bąbelkowym w best case masz 0n czyli dla 100 elementów 100 operacji. Do czego zmierzam:

Console.WriteLine("Po sortowaniu bąbelkowym");
Program.bab(tablica) //Widzisz napis po sortowaniu bąblowym:) ale ty je dopiero odpalasz. 

1. Zaczynasz bąbelkowym (tu pisze,że niby po ale ty je dopiero włączasz) , mega wolno ale sortujesz tablice.

 
 Console.WriteLine("Po sortowaniu po wybieraniu");//Przed sortowaniem nie po.
            Program.wyb(tablica);//

2. Dalej włączasz selection sort który dostaje już POSORTOWANĄ tablice ale on ma to gdzieś zawsze pracuje tak samo.

3)Dalej żeby pokazać czas bubble sort znowu go odpalasz ale tym razem z **POSORTOWANą **tablicą, więc osięga zarąbisty czas bo dla posortowanych ma dobra złożoność.
4) Dalej znowu select sort tak jak w pkt 2.

Ty ja wiem co napisalem i co to robi ja prosilem o pomoc w tym zeby mi to posortowalo, a nie wytlumaczenie tego co juz wiem;>

Pytasz o wyniki czemu taki a nie inne to tłumaczę Ci skąd to bierze.
Wnioskując po:
Sortowanie bąbelkowe zajmuje mi wlasnie tyle okolo 1/10 sekundy, jednak przez wybieranie masakrycznie dlugo sie robi przykladowo 50tysiecy elementow 8sekund.
Nie wiesz. Mylisz sortowania i ich czasy. W złych miejscach sobie wyświetlasz informacje. Mierzenie po 10 razy w buble sortu na tej samej posortowanej tablicy jest bezsensu. Dodatkowo jesteś pewny że 6 milionów? Bo ta twoja notacja z 1 postu jest trochę dziwna...