Drzewa I ich reprezentacje



Pobieranie 34,35 Kb.
Data04.11.2017
Rozmiar34,35 Kb.

Algorytmy i struktury danych

WSB-NLU w Nowym Sączu

Ćwiczenia 12



Drzewa i ich reprezentacje


Nasze rozważania rozpoczniemy od najpopularniejszych i najczęściej używanych drzew, czyli od drzew binarnych.

Podstawowa komórka służąca do konstrukcji drzewa binarnego ma postać:


struct Node

{

Elem info;



struct Node *left, *right;

}
Jak widać mamy tu dwa wskaźniki, które wskazują na lewą i prawą gałąź drzewa binarnego. Zmienna info służy oczywiście do przechowywania danych w węźle. Może to być dowolny typ danych.



Drzewa binarne i wyrażenia arytmetyczne


Jedno z zastosowań drzew binarnych to reprezentacja wyrażeń arytmetycznych. Dowolne wyrażenie arytmetyczne może być zapisane w kilku różnych postaciach zależnie od tego jak będziemy umieszczali argumenty (zwane też operandami) względem operatorów. Operatory dwuargumentowe można umieszczać przed swoimi argumentami, po nich oraz pomiędzy nimi.
Przykład 1

Rozważmy tradycyjne wyrażenie wrostkowej: ((a+b)+x*9)*12. Jego reprezentacja w postaci drzewa binarnego może wyglądać tak:



Jeżeli napiszemy odpowiednie funkcje obsługujące powyższą strukturę danych, to możemy przy pomocą takiej reprezentacji wyrazić dowolnie skomplikowane wyrażenia arytmetyczne i wykonywać na nich operacje.



Ćwiczenie 1


Narysować binarne drzewa reprezentujące poniższe wyrażenia. W których przypadkach drzewo takie możemy zbudować na więcej niż jeden sposób?

  1. (a + b)*(a - b)

  2. a + b + c*3

  3. (2*(3 + 4*(5 + 1/6)) + a)*(2 + x)

  4. (3 + 7*5)/(8 - 1/x)

Dalej będziemy używali następującej struktury danych do przechowywania wyrażeń arytmetycznych w postaci binarnego drzewa wyrażenia:


struct nodeExpr

{

double val;



char op;

nodeExpr *left, *right;

}
W zależności od wartości przechowywanej w polu op struktury nodeExpr wiemy czy dana komórka (węzeł) przechowuje argument liczbowy czy operator!

Przyjmujemy następującą konwencję:


Jeżeli op == ‘0’, to komórka przechowuje wartość w polu val
Zajmiemy się teraz konstrukcją binarnego drzewa wyrażenia, gdy mamy daną tablicę tabOnp przechowującą poprawnie zapisane wyrażenie w ONP. Aby było wygodniej, elementami tej tablicy są struktury nodeExpr. Algorytm wykorzystuje stos i podstawowe operacje na stosie: pop() i push(). Ponadto używamy pomocniczej funkcji isOp(), która zwraca prawdę, gdy argument jest operatorem (np. +, - ).
Dane wejściowe: tabOnp[]

Dane wyjściowe: binarne drzewo wyrażenia z tablicy tabOnp[], o korzeniu wskazywanym przez wskaźnik e.


nodeExpr *e;

for (i=0; i < length(tabOnp); i++)

{

e = new nodeExpr;



if (isOp(tabOnp[i]) == TRUE)

e->op = tabOnp[i].op;

else

{

e->val = tabOnp[i].val;



e-> op = ‘0’;

}

e->left = NULL; e->right = NULL;



if (isOp(tabOnp[i]) == TRUE)

{

nodeExpr *left, *right;



pop(left);

pop(right);

e->left = left;

e->right = right;

}

push(e);


}

Ćwiczenie 2


Wykonać powyższy algorytm budowania drzewa wyrażenia dla następujących wyrażeń (zapisanych już w ONP):

  1. a b +

  2. a b + x y - *

  3. 3 7 + 9 *

  4. x y + x y - *

  5. 2 4 6 8 + * +



Wypisywanie drzewa wyrażenia


Teraz chcielibyśmy obejrzeć drzewo, które zostało zbudowane przez powyższy algorytm. Co ciekawe okazuje się, że sposób interpretacji takiego drzewa zależy od sposobu przechodzenia przez jego gałęzie.

Oto algorytm, który wypisuje drzewo w postaci klasycznej (wrostkowej):


printInfix(e)

{

if e jest liczbą, to print(e);



if e jest operatorem, to {

printInfix(e->left)

print(e->op)



printInfix(e->right)

}

}


Jak widać jest to algorytm rekurencyjny, w którym wykorzystujemy pomocniczą funkcję (print()), która wypisuje swoje argumenty (np. printf(), cout).

Ćwiczenie 3


Wykonać powyższy algorytm, dla drzew zbudowanych w Ćwiczeniu 2.

Ćwiczenie 4


Przetestować poniższą funkcję napisaną w języku C++, która realizuje algorytm wypisywania w postaci infiksowej, wyrażenia reprezentowanego w drzewie. Należy jeszcze dodać warunek zakończenia wywołań rekurencyjnych.
void printInfix(struct nodeExpr *e)

{

if (e->op == ‘0’)



cout << e->val;

else


{

cout << “(“;

printInfix(e->left);

cout << e->op;

printInfix(e->right);

cout << “)”;

}

}

Ćwiczenie 5


Teraz chcemy wypisać wyrażenie w formie beznawiasowej (ONP). Przeanalizować poniższy algorytm zapisany w języku C++.
void printPrefix(struct *e)

{

if (e->op == ‘0’)



cout << e->val << “ “;

else


{

cout << e->op << “ “;

printPrefix(e->left);

printPrefix(e->right);

}

}
Podsumujmy to jeszcze raz:




W zależności od sposobu przechodzenia po drzewie możemy w różny sposób przedstawić jego zawartość bez wykonywania jakiejkolwiek zmiany w strukturze samego drzewa

Obliczanie wartości wyrażenia

Algorytm wartościujący drzewo wyrażenia jest niezwykle prosty w wersji rekurencyjnej. Podkreślmy, że sama definicja wyrażenia arytmetycznego ma charakter rekurencyjny. Idea algorytmu jest następująca: jeżeli w korzeniu drzewa jest liczba lub zmienna, to zwróć tę wartość (wtedy drzewo składa się tylko z tego jednego węzła); w przeciwnym razie oblicz wartość lewego podrzewa, oblicz wartość prawego podrzewa i wykonaj operację na tych wartościach wskazywana przez operator z korzenia. Można to zapisać w pseudokodzie tak:

eval (e)

{

if (e jest liczbą lub zmienną)

return e->val;

else {


op = e->op;

return eval(e->left) op eval(e->right);

}

}


Ćwiczenie 5

Zrealizować w postaci funkcji języka C++ i przetestować ten algorytm. Zakładamy, że na wejściu funkcja otrzymuje poprawne drzewo binarne wyrażenia poprzez wskaźnik do jego korzenia.



Wskazówka:

Zasadniczy kod funkcji może wyglądać tak:


double eval(struct nodeExpr *e)

{

if (e->op == '0')



return (e->val);

else


switch (e->op)

{

case '+' : return eval(e->left) + eval(e->right);



case '-' : return eval(e->left) - eval(e->right);

case '*' : return eval(e->left) * eval(e->right);

case ':' :

case '/' :

if (eval (e->right) != 0)

return (eval(e->left) / eval(e-right));



else EROOR!!! Dzielenie przez zero; stop;

}

}

Powyższy algorytm działa poprawnie przy założeniu, że na wejściu znajduje się poprawne drzewo wyrażenia. W sytuacji, gdy algorytm będzie pracował na niepoprawnym drzewie, to wartościowanie się rozsypie. Poniżej znajduje się bardzo prosta funkcja rekurencyjna, która zwraca 1, gdy drzewo jest poprane i 0 gdy jest niepoprawne.


Ćwiczenie 6

Przeanalizować i zaimplementować poniższą funkcją sprawdzającą poprawność drzewa wyrażenia:


int valid (nodeExpr *e)

{

if (e->op == '0')



return 1;

else


switch (e->op)

{

case '+' :



case '-' :

case '*' :

case ':' :

case '/' :

return valid(e->op) * valid(e->op);

default :



return 0;

}

}



©operacji.org 2017
wyślij wiadomość

    Strona główna