ISUBA: http://www.algoritmy.net/article/65/Eratosthenovo-sito
Bych ti to i napsal, ale nebylo by to moc seriozní vůči tvému vzdělání. I pokud neumíš skoro nic, tak jsou to max. 2-3h.

ISUBA: googli eratosthenovo síto...

a mimochodem, sem by se to hodilo asi více
[ Algoritmy všeho druhu :: podělte se, pochlubte se, diskutujte etc... ]

SLUPKA: Jestli ten kód budeš psát v C nebo C# bude u QS docela minimální rozdíl...

CERMINEK: to už není moc otázka v C#, ale QS funguje cca následujícím způsobem:

- pokud je QS zavolán na pole o velikosti jedna, tak nedělá nic, vrací nezměněné pole (je již seřazené)

- když je QS zavolán na delší pole, tak nejdříve zvolí nějakým způsobem pivot (třeba první prvek v poli) a rozdělíš pole na dvě pole - prvky které jsou <= než pivot a prvky > pivot... a pak zavoláš rekurzivně QS na první a na druhé pole... první i druhé pole se ti vrátí seřazené, když je dáš za sebe, tak máš seřazené celé původní pole a to vrátíš

No a tohle byl teoretický popis, prakticky se to dělá tak, že se nevytváří žádný další pole, ale dělá se to v oblasti toho pole. Ten index odkud a kam ti určuje, s jakým polem pracuješ (to kolem jakoby neexistovalo). A ty uděláš to, že v rámci této oblasti vybereš pivot a přeuspořádáš prvky této části tak, aby jsi na začátku měl opět prvky <= pivot a pak zavoláš QS na tuto oblast a QS na zbylou oblast.

Takže první zavolání QS musí být od začátku až do konce pole, aby to fungovalo :))

SLUPKA: http://pastebin.com/tGAk2jtw Už to fachá, jen musím vyřešit samotný Quck sort... Kdy dumám nad nějakou vhodnou volbou hranic oblasti...

CERMINEK: Co se týká quicksortu, tak se mi nechce studovat ten kód, pokud by byl opravdu blbě, tak to přepostni pořádně, rovnou z visualka do pastebinu.

Ale řádek
polequick = quick(pole,5,5);//srovná 'pole' metodou quick sort do pole 'polequick'
podle mého dobře nebude :))

Jdu spát, snad to uvidíš :))

ESY:
SLUPKA:
Supér díky moc! Už to generuje jak má!

Ještě doladím ten Quick Sort a hotovo... To by bylo abych se ten C# nenaučil.. ale pořád mám tendence psát assemblerovský a C příkazy... Ještě, že C je tomu blízské a VisuaStudio má tu vlezlou nápovědu :)

CERMINEK:
for (int i = 0; i < velikost; i++)
{
Random j = new Random();
polecisel[i] = j.Next(-100, 100);
}

to je z tohoto důvodu... generátor náhodných čísel si vytvoř jeden a ten používej... když voláš new Random(), tak se ti do něj dá seed v závislosti na čase a Next pak pracuje deterministicky v závislosti na tom seedu, takže ze stejného seedu udělá stejné číslo...

ESY: takze kdyz krokujes tak je ten cas jinej

CERMINEK: nepouzivej new Random();
ale .Next() ...
Random se generuje z casu. ty vytvoris pokazdy stejnou vec v stejnej cas..

MORMEGIL: Tak jsem to zkusil. Původní pole si v pohodě přenáším. Stále ale nevím proč, když to pustím "v plné rychlosti", tzn. nekrokuji, tak se mi pole naplní jedním stejným číslem do všech buňek...

MORMEGIL: Super! Moc díky!

SLUPKA: Příště už to použiji :)

jen taková poznámka, když vkládáte takhle delší kus kódu, tak použijte například pastebin ( http://pastebin.com/ ). Má to výhodu, že je kód čitelnější, takže se pak i snadněji radí...

CERMINEK: V tom kódu máš očividný nesmysl v tom, že nejdřív přiřadíš např. do polebubble novou instanci pole intů, načež do něj přiřadíš výsledek metody bubble, takže tu instanci zase zahodíš. Místo toho si po vyrobení té nové instance do ní původní pole okopíruj a pak do řadicí metody předej už tu kopii (a návratovou hodnotu změň na void, není k ničemu):

int[] polebubble = new int[pole.Length];
Array.Copy(pole, polebubble, pole.Length);
bubble(polebubble);
vypispole(polebubble);

Anebo ještě jednodušeji:

int[] polebubble = (int[])pole.Clone();
bubble(polebubble);
vypispole(polebubble);

PIGSTER: Jak to obejít aby v tom původním poli bylo to původní a do těch dvou se to seřadilo těmi funkcemi?

CERMINEK: no to protoze to pole tam predavas odkazem - protoze vsechno v .NETu krome struktur a zakladnich datovejch typu se predava odkazem

Ahoj. Mám otázečku k mému Dů do školy... Nějako mi to není jasné a to je to přitom úroveň C, kterou ještě zvládám.

Oč jde... Tahle konzolovka má srovnat pole dvěma metodami - bubble sort a quick sort, algorytmi jsou OK. Ale není mi jasné proč po tom, co udělám bubble sort s jeho funkcí, kdy má být seřazení uloženo jen do pole 'polebubble'. Seřazení proběhne a v 'polebubble' jsou hodnoty seřazeny,ale v poli 'pole', kde mají zůstat jen původní náhodná čísla bez seřazení, se záhadně seřadí a nejsem schopen říct proč.

Taky mě zaráží další fakt, že když pustím program naplno v plné rychlosti, tak jsou v poli stejná čísla... Čím to je?

Všem moc díky za rady!

class Program
{
static void Main(string[] args)
{
Console.WriteLine("Michal Čermák - Domácí úkol č.1 - PPR");

int[] pole = novepole();//generuje pole náhosných čísel zvolené velikosti
vypispole(pole);//vypíše pole

int[] polebubble = new int[pole.Length];
polebubble = bubble(pole);//srovná 'pole' metodou bubble sort do pole 'polebubble'
vypispole(polebubble);//vypíše pole

int[] polequick = new int[pole.Length];
polequick = quick(pole,5,5);//srovná 'pole' metodou quick sort do pole 'polequick'
vypispole(polequick);


Console.ReadKey();
}

//Funkce pro generování pole o proměnné velikosti a jeho naplnění náhodnými čísly
static int[] novepole()
{

// !!! při plném spuštění přes F5 vypíše stejná čísla
//načtení požadované velikosti pole
Console.Write("Zadejte velikost pole: ");
int velikost = Convert.ToInt16(Console.ReadLine());
int[] polecisel = new int[velikost];

for (int i = 0; i < velikost; i++)
{
Random j = new Random();
polecisel[i] = j.Next(-100, 100);
}


return polecisel;
}

//Funkce pro výpis jakéhokoliv pole do řádku
static void vypispole(int[] poleprovypis)
{
foreach (int i in poleprovypis)
{
Console.Write("{0, 5}", i);
}
Console.WriteLine();
}

//Funkce BUBBLE sort metody ttřídění pole
//optimalizace: dopředný i zpětný průchod
//Vzestupný postup - opačně s přehozením znamének
static int[] bubble(int[] polebubble)
{

for (int i = 0; i < polebubble.Length / 2; i++)
{
bool zamena = false;

for (int j = i; j < polebubble.Length - i - 1; j++)
{
if (polebubble[j] > polebubble[j + 1])
{
int tempnum = polebubble[j];
polebubble[j] = polebubble[j + 1];
polebubble[j + 1] = tempnum;
zamena = true;
}
}
for (int j = polebubble.Length - 2 - i; j > i; j--)
{
if (polebubble[j] < polebubble[j - 1])
{
int tempnum = polebubble[j];
polebubble[j] = polebubble[j - 1];
polebubble[j - 1] = tempnum;
zamena = true;
}
}
if (!zamena) break;
}
return polebubble;
}


//Funkce QUICk sort metody třídění pole
//při velikosti pole <=10 není zrovna výhodný
//potíže jsou s volbou hranic
static int[] quick(int[] polequick, int hraniceleva, int hraniceprava)
{
if (hraniceleva < hraniceprava){
int boundary = hraniceleva;
for (int i = hraniceleva + 1; i < hraniceprava; i++)
{
if (polequick[i] > polequick[hraniceleva])
{
prohozeni(polequick, i, ++boundary);
}
}
prohozeni(polequick, hraniceleva, boundary);
quick(polequick, hraniceleva, boundary);
quick(polequick, boundary + 1, hraniceprava);
}
return polequick;
}

private static void prohozeni(int[] poleprohozeni, int hraniceleva, int hraniceprava) {
int tempnum = poleprohozeni[hraniceprava];
poleprohozeni[hraniceprava] = poleprohozeni[hraniceleva];
poleprohozeni[hraniceleva] = tempnum;
}
}