Elektrotehnički fakultet

Banja Luka
Katedra za računarsku tehniku

STRUKTURE PODATAKA I ALGORITMI

Laboratorijska vježba 3
Priprema
1. Ponoviti stablo.
2. Analizirati sljedeći kod:
// Obilazak stabla -- rekurzivna realizacija
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

typedef int tip;

typedef struct treeNode treeNode;
struct treeNode
{
tip element;
treeNode *left;
treeNode *right;
};

treeNode* newNode(tip element)

{
treeNode *tn = (treeNode*)malloc(sizeof(treeNode));
tn->element = element;
tn->left = tn->right = NULL;
return tn;
}

void preOrderRek(treeNode *root)

{
if (root == NULL) return;
printf("%d ", root->element);
preOrderRek(root->left);
preOrderRek(root->right);
}

void inOrderRek(treeNode *root)

{
if (root == NULL) return;
inOrderRek(root->left);
printf("%d ", root->element);
inOrderRek(root->right);
}

void postOrderRek(treeNode *root)

{
if (root == NULL) return;
postOrderRek(root->left);
postOrderRek(root->right);
printf("%d ", root->element);
}

int main()
{
treeNode *root;
// Kreiramo stablo:
 // 0
// / \
// 1 2
// / \ / \
// 3 4 5 6
// / \
// 7 8

root = newNode(0);

root->left = newNode(1);
root->right = newNode(2);

root->left->left = newNode(3);
root->left->right = newNode(4);

root->right->left = newNode(5);
root->right->right = newNode(6);

root->left->left->left = newNode(7);
root->left->left->right = newNode(8);

printf("Preorder obilazak:\n");
preOrderRek(root);

printf("\nInorder obilazak:\n");
inOrderRek(root);

printf("\nPostorder obilazak:\n");
postOrderRek(root);

system("pause");
}

3. Ponoviti grafove.
4. Analizirati sljedeći kod:
#include <stdio.h>
#include <stdlib.h>

// FIFO red:
#define MAXRED 128
typedef int tip;
int enqueue (tip element, tip queue[], int n, int izlaz, int *ulaz) {
if (((*ulaz+1) % n) == izlaz) return 0;
(*ulaz) = (*ulaz+1)%n;
queue[*ulaz] = element;
return 1;
}

int dequeue (tip *element, tip queue[], int n, int *izlaz, int ulaz) {
if (ulaz == *izlaz) return 0;
(*izlaz) = (*izlaz+1)%n;
*element = queue[*izlaz];
return 1;
}

// graf:
#define MAXNODES 128
typedef struct node node;

struct node
{
int element;
node *next;
};

typedef node* graph[MAXNODES];

node* newNode(int element)

{
node* nd = (node*) malloc(sizeof(node));
nd->element = element;
nd->next = NULL;
return nd;
}

void bfs(graph g, int start)

{
tip queue[MAXRED] = {0};
int ulaz=0, izlaz=0;
int v;
char visit[MAXNODES] = {0};
visit[start] = 1;
enqueue(g[start]->element, queue, MAXRED, izlaz, &ulaz);
while (dequeue(&v, queue, MAXRED, &izlaz, ulaz)) // red nije prazan
{
printf("%d ", v);
node* curr = g[v];
curr = curr->next;
while (curr != NULL)
{
int u = curr->element;
if (!visit[u])
{
visit[u] = 1;
enqueue(u, queue, MAXRED, izlaz, &ulaz);
}
curr = curr->next;
}
}
}

int main()
{
graph g;

FILE* fin = fopen("graphInput.txt", "r");

if (fin == NULL) exit(-1);

/*
Topologija grafa cita se iz fajla graphInput.txt. Za svaki cvor grafa (u)
u fajlu se nalaze relacije susjednosti u sljedecem formatu:

u v1 v2 v3 .. vn -1

gdje su v1, v2, ... cvorovi koji su susjedni cvoru u. Vrijednost -1

je terminator liste. U fajlu ima onoliko redova koliko graf ima cvorova.
*/
while (!feof(fin))
{
int num, fnum = 0;
fscanf(fin, "%d", &num);
g[num] = newNode(num);
node* curr = g[num];
while (!feof(fin))
{
fscanf(fin, "%d", &fnum);
if (fnum == -1) break;
curr->next = newNode(fnum);
curr = curr->next;
}
}
printf("BFS:\n");
bfs(g,0);

system("pause");
}
 5. Analizirati sljedeći kod:
void dfsVisit(graph g, node* vertex, char visit[])
{
visit[vertex->element] = 1;
printf("%d ", vertex->element);
node* curr = g[vertex->element];
curr = curr->next;
while (curr != NULL)
{
if (!visit[curr->element])
dfsVisit(g, curr, visit);
curr = curr->next;
}
}

void dfs(graph g, int start)

{
int i;
char visit[MAXNODES] = {0};
dfsVisit(g, g[start], visit);
}