Vissza

Divide et impera
  1. Összefésüléses rendezés, mergesort: rendezzük növekvő sorrendbe az x[1..n] tömbben tárolt számsorozatot, összefésüléses rendező algoritmust alkalmazva. ( Pszeudokód )
  2. Gyorsrendezés, quicksort: rendezzük növekvő sorrendbe az x[1..n] tömbben tárolt számsorozatot, gyorsrendezési  algoritmust alkalmazva (Pszeudokód) ­
  3. Bináris keresés, binary search: adott egy szigorúan növekvő számsorozat, amelyet az x[1..n] tömbben tárolunk, valamint egy a  szám. Írjunk rekurzív függvényt, amely visszatéríti az a szám tömbbeli sorszámát, ha megtalálható a tömbben. A függvény -1-t térít vissza, ha a szám nincs benne a tömbben.
  4. Adott egy nxm -es kétdimenziós tömb, mely 1 és 0 értékeket vehet fel. Az 1-es értékek lyukakat jeleznek a tömbben. Határozzuk meg azt a legnagyobb területű téglalapot, megadva a tömbbeli koordinátáit (sor, oszlop) melyben nincsenek lyukak, rekurzív eljárást írva.
  5. Fraktálok: Forráskód, háromszög fraktálra
  6. Rajzoljuk ki a képernyőre az n-edik szintű, D széles, Koch fraktált. Példa 0, 1 és 2 szintű Koch fraktálokra: ( Pszeudokód )
Összefésüléses rendezés, pszeudokód:
Mergesort( tomb, p, r)
    ha ( p < r ) akkor
        q = (p+r)/2
        Mergesort(tomb, p, q)
        Mergesort(tomb, q+1, r)
        Merge(tomb, p, q, r)  
    vege ha
vege Mergesort

Merge(A, p, q, r)
    minden j = p, r vegezd
        B[j] = A[j]
    vege minden
    k = i = p, j= q+1
    amig i ≤q es j ≤r
        ha B[i] < B[j] akkor
            A[k] = B[i]
            i = i+1
        maskepp
            A[k] = B[j]
            j = j+1
       vege ha
       k = k+1
    vege amig
    amig i ≤ q
        A[k] = B[i]
        k = k+1
        i = i+1
    vege amig
    amig j ≤ r
        A[k] = B[j]
        k = k+1
        j = j+1
    vege amig
vege Merge

Gyorsrendezés pszeudokód
QuickSort(tomb, p, r)
    ha p < r akkor
        q = Feloszt(tomb, p, r)
        QuickSort(tomb, p, q)
        QuickSort(tomb, q+1, r)
    vege ha
vege QuickSort

Feloszt(A, p, r)
    i = p-1, j = r+1
    x = A[p]
    amig IGAZ vegezd
        vegezd
            i = i+1
        amig A[i] < x
        vegezd
            j=j-1
        amig A[j] > x
        ha i<j akkor
            Csere(A[i], A[j])
        kulonben return j
    vege amig
vege Feloszt

Háromszög fraktál:

#include <graphics.h>
#include <conio.h>
#include <math.h>
#include <stdlib.h>
void haromszog(int x1,int y1,int x2,int y2,int x3,int y3,int k)
{
    line(x1,y1,x2,y2);
    line(x1,y1,x3,y3);
    line(x2,y2,x3,y3);
    if (k) {
        haromszog(x1,y1,(x1+x3)/2,(y1+y3)/2,(x1+x2)/2,(y1+y2)/2,k-1);
        haromszog(x2,y2,(x1+x2)/2,(y1+y2)/2,(x2+x3)/2,(y2+y3)/2,k-1);
        haromszog(x3,y3,(x1+x3)/2,(y1+y3)/2,(x2+x3)/2,(y2+y3)/2,k-1);
        floodfill((x1+x2+x3)/3,(y1+y2+y3)/3,WHITE);
    }
}

int main()
{
    int gd,gm;
    gd = gm = 0;
    initgraph(&gd,&gm,"");
    setcolor(WHITE);
    setfillstyle(1,WHITE);
    haromszog(0,479,639,479,320,0,4);
    getch();
    closegraph();
    return 0;
}

Koch görbe pszeudokód
Kezdeti hivas:
f = 3;
rajz(0,200,0,600);

rajz(x, y, alfa, d)
    ha d > f akkor
    d = d / 3;
    rajz(x, y, alfa, d);
    rajz(x+d*cos(alfa), y+d*sin(alfa), alfa+pi/3, d);
    rajz(x+d*cos(alfa)+d*cos(alfa+pi/3), y+d*sin(alfa)+d*sin(alfa+pi/3), alfa-pi/3, d);
    rajz(x+2*d*cos(alfa), y+2*d*sin(alfa), alfa, d);
  kulonben
   line(ceil(x), ceil(480-y), ceil(x+d*cos(alfa)), 480-ceil(y+d*sin(alfa)))
    vege ha
vege rajz