[Turbo Pascal] Pomoč...

V šoli smo dobil neke vaje za narest in dveh nalog ne razumem oz. ne znam rešit, pa bi vas prosu za pomoč če lahko.

1. naloga - rekurzije
Napišite program za hitro sortiranje tabele petdesetih števil.

2. naloga - podatkovne strukture, kazalci,...
Dana je podatkovna struktura:

var z : array[1..30] of ^integer;

Inicializirajte podatkovno strukturo tako, da bo vsak izmed integerjev v strukturi dobil vrednost, ki je enaka vrednosti indeksa tabele.

Vsakršna pomoč je dobrodošla.
Tnx

Prva: poisci kje na netu algoritem za quicksort. ;)

Heh, ta druga je pa izi. Upam le da se ne zmotim v sintaksi a to bos ze znal popraviti.

var i:integer;
for i=1 to 30 do
begin
new(z[i]);
z[i] := i;
end;

QuickSort je dodan k Turbo Pascal 7 za DOS.

No ce ne najdes quicksorta si lahko se vedno sam izmislis program ki bo rekurzivno sortiral tabelo...

Cesa tocno tu ne znas (upam da odgovor ne bo 'pascala')?

Gundolf z[i]^:=

drugače nastavljaš pointer ;)) kar ni nevem kako krasno ;) ampak dela pa tudi ker pointer == stevilka.

Hvala Primoz, sm vedu da se bom nekje zmotu. Bolje da to se Grayu poves ;)

Gray, nimam pojma kaj so to premene tako da ne vem ce bi slo :) Razmisljaj v tej smeri: v neki funkciji sortiras en del tabele, nato to funkcijo rekurzivno klices na nesortiranem preostanku. Lahko pa v funkciji delno sortiras tabelo na dva dela in funkcijo nato rekurzivno klices na obeh teh delih. Moznosti je veliko.

{ Turbo Sort }
{ Copyright (c) 1985,90 by Borland International, Inc. }

program qsort;
{$R-,S-}
uses Crt;

{ This program demonstrates the quicksort algorithm, which }
{ provides an extremely efficient method of sorting arrays in }
{ memory. The program generates a list of 1000 random numbers }
{ between 0 and 29999, and then sorts them using the QUICKSORT }
{ procedure. Finally, the sorted list is output on the screen. }
{ Note that stack and range checks are turned off (through the }
{ compiler directive above) to optimize execution speed. }

const
max = 1000;

type
list = array[1..max] of integer;

var
data: list;
i: integer;

{ QUICKSORT sorts elements in the array A with indices between }
{ LO and HI (both inclusive). Note that the QUICKSORT proce- }
{ dure provides only an "interface" to the program. The actual }
{ processing takes place in the SORT procedure, which executes }
{ itself recursively. }

procedure quicksort(var a: list; Lo,Hi: integer);

procedure sort(l,r: integer);
var
i,j,x,y: integer;
begin
i:=l; j:=r; x:=a[(l+r) DIV 2];
repeat
while a[i] < x do i:=i+1;
while x < a[j] do j:=j-1;
if i < = j then
begin
y:=a[i]; a[i]:=a[j]; a[j]:=y;
i:=i+1; j:=j-1;
end;
until i>j;
if l < j then sort(l,j);
if i < r then sort(i,r);
end;

begin {quicksort};
sort(Lo,Hi);
end;

begin {qsort}
Write('Now generating 1000 random numbers...');
Randomize;
for i:=1 to max do data[i]:=Random(30000);
Writeln;
Write('Now sorting random numbers...');
quicksort(data,1,max);
Writeln;
for i:=1 to 1000 do Write(data[i]:8);
end.