http://avl.ansi-c.pl/

Idąc za ciosem postanowiłem zainstalować pakiet compiz-fusion oraz ustawić odpowiedni motyw, ostatnią rzeczą do zrobienia było wybranie panoramicznej tapetki. Muszę przyznać iż google naprawdę się postarało i tym oto sposobem chciałbym polecić wszystkim dwie świetne witryny z masą wspaniałych tapet.

http://wallpaperstock.net/

http://interfacelift.com/

Szkoda że nie można mieć ich wszystkich na pulpicie ;d

http://www.mjmwired.net/resources/mjm-fedora-f9.html

1. Grafika 3D jest działem, w którym przedstawiłem kilka swoich prac wykonanych w programie Zanoza Modeler z czasów gdy jeszcze zajmowałem się tworzeniem dodatkowych samochodów do serii Grand Theft Auto.
2. Programowanie zawiera listę wpisów związanych z programowaniem wraz z krótkim opisem.
3. W dziale Webdesign znajdziecie kilka przykładów layoutów, które wykonałem z nudów, jednak nie są one brane przeze mnie poważnie, raczej jako zabawa z photoshopem.

Niedługo zamierzam napisać trochę o drzewach BST jako wstęp do ich specyficznej, ale za to jak świetnej, odmiany AVL. Wyjaśnię tylko że drzewa AVL są zrównoważonymi drzewami BST za pomocą których wyszukiwanie elementu w pesymistycznym przypadku wynosi 1.44logN, w przeciwieństwie do drzew BST gdzie wynik jest niestety liniowy.

Pozdrawiam

Opis problemu

Skoczek jest takim typem figury, którego ruch wykonujemy poruszając się dwa pola dalej na poziomej lub pionowej osi, a następnie wykonujemy przesunięcie o jedno pole po tej drugiej osi. Innymi słowy bardziej przystępny będzie typowy obrazek przedstawiający wszystkie możliwe ruchy skoczka.

Wszystkich możliwych ruchów, jak widać na obrazku powyżej, jest 8. Sam opis problemu jest prosty, a mianowicie jak przejść skoczkiem po całej szachownicy pojawiając się na każdym z pól tylko jeden raz?

Rozwiązanie tego problemu jest dosyć proste w zrozumieniu oraz, jeśli znamy ideę działania algorytmów z powrotami(jeśli nie to nie martwcie się, postaram się to wyjaśnić w dalszej części artykułu), w implementacji.

Chodzi w uogólnieniu o sprawdzanie każdej drogi jaką możemy przejść korzystając z dostępnych dla skoczka ruchów. Ideę algorytmów z powrotami możemy porównać do sytuacji gdy jakiś niewdzięcznik wsadził nas do labiryntu, a przy sobie mamy tylko jakąś nitkę i przykładowo młotek z gwoźdźmi. Przez chwilę zastanawiamy się jak efektywnie znaleźć drogę do wyjścia nie biegając w kółko i wchodząc w byle jakie korytarze. Po chwili namysłu przybijamy jeden koniec naszej nitki w miejscu z którego zaczęliśmy i umawiamy się że w przypadku pojawienia się rozdroża (nasz tunel w pewnym miejscu rozbiega się na kilka innych tuneli) wybieramy tunel zgodnie z ruchem wskazówek zegara, a w przypadku natrafienia na ślepy zaułek cofamy się do ostatniego rozdroża i wybieramy kolejną drogę, gdy okaże się że wszystkie rozgałęzienia w danym rozdrożu są ślepymi zaułkami cofamy się jeszcze bardziej i tak cały czas aż uda nam się wyjść i przetrzepać naszego niewdzięcznika. Innymi słowy prosta recepta do celu.

Podobnie postąpimy z problemem skoczka rozdrożem będzie każde pole szachownicy, ale zamiast przechodzić z niego na następne, chodzić będziemy po 8 możliwych dla każdego pola (jak można wywnioskować z tabeli dostępnych ruchów. Cofać będziemy się gdy miejsce na które chcemy przejść będzie poza obszarem szachownicy lub będzie oznaczone jako takie na którym już wcześniej stał nasz skoczek. W końcowym rezultacie znajdziemy się na ostatnim wolnym polu na szachownicy dzięki czemu rozwiążemy zadanie.

Do rozwiązania problemu posłużymy się jedną funkcją, którą będziemy wywoływać rekurencyjnie z różnymi parametrami. Każdy ruch będziemy numerować, po pierwsze aby było można odtworzyć trasę skoczka korzystając z tablicy dwuwymiarowej, w której to wartością danego pola będzie numer ruchu w którym skoczek je odwiedził, a zero jeśli pole nie zostało jeszcze odwiedzone. Po drugie w końcowym momencie algorytmu zdarzy się sytuacja gdy skoczek będzie w ostatnim miejscu i nie będzie już możliwości ruchu bo ukończyliśmy zadanie, w tym wypadku dzięki informacji o numerze ruchu możemy zwrócić informację o poprawnym zakończeniu algorytmu. Sama funkcja będzie zwracać 0 jeśli wszystko przebiegło pomyślnie lub 1 jeśli musimy powrócić z jakiegoś miejsca i szukać dalej. Teraz uwaga, w związku z konfliktem nazw numer ruchu jako numer aktualnego posunięcia skoczka to nrRuchu, a numer ruchu jako numer jednej z 8 możliwości ruchu skoczka to nrPrzesunięcia. Wartości przesunięć będziemy przechowywać w tablicy dwuwymiarowej 8×2 gdzie pierwszy indeks to nr przesunięcia, a drugi do index osi po której się poruszamy (dla lepszej organizacji kodu lepiej zrobić własną strukturę, ale akurat tutaj postanowiłem nie wprowadzać tego). W praktyce wygląda to tak:

ruchy[0][0]=-2; ruchy[0][1]=1;
ruchy[1][0]=-1; ruchy[1][1]=2;
ruchy[2][0]=1; ruchy[2][1]=2;
ruchy[3][0]=2; ruchy[3][1]=1;
ruchy[4][0]=2; ruchy[4][1]=-1;
ruchy[5][0]=1; ruchy[5][1]=-2;
ruchy[6][0]=-1; ruchy[6][1]=-2;
ruchy[7][0]=-2; ruchy[7][1]=-1;

Jak widać do określenia jednego przesunięcia potrzebne są nam dwie wartości, teraz kod naszej głównej funkcji w języku ANSI C:

int Ruch(int nrRuchu, int wspX, int wspY) {
int NastWspX,NastWspY,nrPrzesuniecia=-1;
do {
nrPrzesuniecia++;
NastWspX=wspX+ruchy[nrPrzesuniecia][0];
NastWspY=wspY+ruchy[nrPrzesuniecia][1];
if(NastWspX>=0&&NastWspX=0&&NastWspY
if(tablica[NastWspX][NastWspY]==0) {
tablica[NastWspX][NastWspY]=nrRuchu;
if(nrRuchu
if(Ruch(nrRuchu+1,NastWspX,NastWspY)==0) return 0;
else tablica[NastWspX][NastWspY]=0;
} else return 0;
}
}
} while(nrPrzesuniecia!=8);
return 1;
}

Jak widać argumentami naszej funkcji są aktualna pozycja skoczka oraz numer aktualnego ruchu(uwaga: szerokosc i wysokosc sa zmiennymi globalnymi), obliczamy w prosty sposób wartość kolejnej współrzędnej oraz sprawdzamy czy pole o takich współrzędnych znajduje się w obrębie tablicy oraz czy nie było odwiedzone wcześniej, w przypadku gdy któreś z tych warunków jest niespełniony następuje wyjście z pętli if i wykonanie pętli while kolejny raz, w przypadku gdy każdy z 8 dostępnych dla nas ruchów był niewypałem funkcja zwraca wartość 1 co oznacza że z tego pola nie da się iść dalej w takiej konfiguracji poprzednich ruchów. Jednak w przypadku gdy jakieś pole jest wolne to stawiamy na nie naszego skoczka i sprawdzamy czy to przypadkiem już nie koniec, jeśli to nasz ostatni ruch (a wiemy że liczba ruchów potrzebnych do przejścia szachownicy wynosi szerkosc szachownicy razy jej wysokosc) to zwrazamy wartość 0. Został nam jeszcze do omówienia najgłębszy element, w pętli if wywołujemy funkcję Ruch z nowymi parametrami i czekamy na jej wynik, jeśli zwróci 1 to jak już wiemy oznacza ślepy zaułek, po czym odznaczamy miejsce które oznaczyliśmy wcześniej i wywołujemy kolejny przebieg pętli while, która sprawdzi kolejną możliwość, jeśli jednak dostaniemy 0 to szczęśliwi informacją o powodzeniu naszej misji zwracamy 0 poprzednim wywołaniom funkcji. Tym oto sposobem rozwiązaliśmy problem, a dzięki tablicy z wartościami pól łatwo odtworzymy wybraną trasę.

Na koniec spora uwaga, a właściwie to dwie. Po pierwsze w przykładzie użyliśmy szachownicy o dowolnym rozmiarze, ale nie dla każdej tablicy istnieje rozwiązanie, przykładowo zróbcie na kartce tescik dla tablicy 3×3. Wniosek? Po prostu się nie da. Po drugie uważajcie na rozmiar tablicy oraz punkt startowy, który tutaj też jest dowolny, jako że algorytm jest typowo brutalny (brute-force) w pewnych przypadkach, albo przy dużej szachownicy albo przy niefortunnym wybraniu punktu startowego, może liczyć się baaardzo długo albo nawet i „wiecznie” mimo waszych nowiusieńkich CoreQuad.

Mam nadzieję że na tym przykładzie zrozumieliście ideę algorytmów z powrotami, w razie jakichś pytań proszę słać je na mail lub lepiej zostawić tutaj w komentarzu. To by było na tyle…

Standardowy QuickSort w ANSI C wygląda tak:

void quicksort(int *tab, int left, int right) {int i,j;
int x;
x = tab[(left+right)/2];
i=left;
j=right;
do {
while(tab[i]<x) ++i;
while(tab[j]>x) –j;
if(i<=j) {
int tmp;
tmp = tab[i];
tab[i] = tab[j];
tab[j] = tmp;
++i;
–j;
}
} while(i<j);
if(left<j) quicksort(tab,left,j);
if(right>i) quicksort(tab,i,right);
}

Nie będę tłumaczył kodu zwykłego QuickSorta, gdyż można go znaleść chociażby na wikipedii. Jak widać w ostatnich linijkach znajdują się wywołania rekurencyjne funkcji, by je zlikwidować użyjemy prostej struktury stosu.

Zasada działania

Gdy wywołamy pierwszy raz główną funkcję programu po ciągu instrukcji ta sama funkcja wywoła siebie dwa razy i będzie dalej działała na dwóch mniejszych fragmentach tablicy, które później znowu zostaną podzielone. W tym wypadku każda z tych dwóch części jest od siebie niezależna (tzn. działając na jednej nie obchodzi nas co jest w drugiej). Idąc dalej tym tropem możemy odłożyć sobie sortowanie jednej części i pozostać w tej drugiej.

W przypadku naszego programu cały algorytm obejmiemy pętelką while, która będzie się wykonywać do czasu aż na naszym stosie zabraknie danych do obróbki. Sam element stosu będzie zawierał początkowy i końcowy indeks części która ma być później przerobiona.

Zabierzmy się zatem do realizacji stosu, użyjemy tu 3 funkcji: pop służącej do zdejmowania elementu ze stosu, push dzięki której będziemy odkładać elementy na stos i funkcji czyPusty zwracającej 0 jeśli stos jest pusty lub 1 jeśli coś znajduje się na nim.

Element stosu zdefiniujemy tak:

struct stos {
int lewyIndeks;
int prawyIndeks;
struct stos *nast;
};

Zainicjalizujemy wskaźnik globalny trzymający adres szczytowego elementu stosu

struct stos *glowa=NULL;

I zajmiemy się definicją funkcji stosowych

int czyPusty() {
if(glowa==NULL) return 0;
else return 1;
}

Oczywiście stos jest pusty tylko wtedy gdy wskaźnik glowa jest równy wartości NULL

void push(int lewy, int prawy) {
struct stos *tmp;
tmp = (struct stos *)malloc(sizeof(struct stos));
tmp->lewyIndeks=lewy;
tmp->prawyIndeks=prawy;
if(glowa==NULL) tmp->nast=NULL;
else tmp->nast=glowa;
glowa=tmp;
}

Alokujemy miejsce w pamięci na nowy element, przypisujemy mu odpowiednie wartości, a następnie wrzucamy go na stos.

void pop(int *lewy, int *prawy) {
*lewy=glowa->lewyIndeks;
*prawy=glowa->prawyIndeks;
struct stos *tmp;
tmp=glowa;
glowa=glowa->nast;
free(tmp);
}

Tutaj wysyłamy wartości szczytowego elementu stosu do zmiennych podanych w argumentach funkcji oraz usuwamy szczytowy element ze stosu.

Mający wszystkie niezbędne funkcji należy tylko zmodyfikować funkcję sortującą

void quicksort(int *tab) {
int i,j,lewy,prawy;
int x;
while(czyPusty()==1) {
pop(&lewy,&prawy);
x = tab[(lewy+prawy)/2];
i=lewy;
j=prawy;
do {
while(tab[i]<x) ++i;
while(tab[j]>x) –j;
if(i<=j) {
int tmp;
tmp = tab[i];
tab[i] = tab[j];
tab[j] = tmp;
++i;
–j;
}
} while(i<j);
if(prawy>i) push(i,prawy);
if(lewy<j) push(lewy,j);
}
}

Jak widzimy na początku pętli while zamiast pobierać wartości lewy i prawy z argumentów funkcji pobieramy je ze stosu, a na końcu tej samej pętli zamiast wywoływać rekurencyjnie funkcję z innymi parametrami to odkładamy je na stos.

Przed uruchomieniem funkcji należy odłożyć na stos krańcowe indeksy tablicy, którą chcemy posortować.

Pozdrawiam Konrad Szczęśniak