Tentamen i Algoritmer och datastrukturer, fredagen den 13 april 2012

student.ch.lu.se

Tentamen i Algoritmer och datastrukturer, fredagen den 13 april 2012

Tentamen i Algoritmer och datastrukturer,

fredagen den 13 april 2012

Tillåtet hjälpmedel: Java snabbreferens + beskrivning av vissa klasser och interface som delas ut.

Maxpoäng är 36, för godkänt krävs 18 poäng. Preliminär poäng per uppgift anges nedan.

Uppgifterna är inte sorterade i svårhetsgrad.

Uppgift 1 (7 p)

Vad är tidskomplexiteten för följande algoritmer? Variabeln n bör användas för att beskriva

”storleken” på problemet. Skriv inte bara upp ett svar utan motivera det också!

a) int i = 1;

int j = 1;

while (j < n){

for (int k = 1; k


Uppgift 2 (8 p)

I denna uppgift ska vi implementera en klass för ett heap-format träd med begränsad storlek,

LimitedTree. I konstruktorn anger man hur många element som trädet får innehålla. Om man

anropar operationen för insättning när trädet är fullt så sker inte någon insättning. Elementen ska

lagras i en vektor på det sätt som man brukar göra med heap-formade träd. Försöker man ta ut ett

element ur ett tomt träd så returneras null av remove. Observera att trädet är heap-format men

att det inte är partiellt ordnat! Ordningen är helt oväsentlig. Klassen ser ut så här:

public class LimitedHeapTree{

private E[] heapArray; /* Här lagras elementen */

private int maxSize; /* Anger det maximala antalet element i trädet. */

private int size; /* Anger det aktuella antalet element i trädet. */

public LimitedHeap(int maxSize){…} /* Konstruktorn för klassen. */

public void insert(E x){…} /* Sätter in x i om det finns plats, x ska placeras

på rätt plats i vektorn så att heapformen behålls */

public E remove(){…} /* Tar bort och returnerar roten i trädet och arrangerar om

vektorn så att vi fortfarande har ett heapformat träd */

public boolean isFull(){…} /* Returnerar true om trädet är full annars

false */

}

a) Implementera konstruktorn. Implementera också insert, remove och isFull. Du får

inte införa några attribut utöver de som redan finns! Elementen ska lagras i vektorn på det

sätt som man gör när man implementerar ett heapformat träd med en vektor.

b) Vi ska göra ett tillägg till klassen så att man kan iterera över elementen i trädet. Därför lägger

vi till en metod i LimitedHeapTree som returnerar en iterator:

public Iterator iterator(){

return new LimitedHeapIterator();

}

LimitedHeapIterator är en inre klass i LimitedHeapTree. Den ser ut så här:

private class LimitedHeapIterator implements Iterator{

private int position;

private LimitedHeapIterator (){…} /* Konstruktorn! */

public boolean hasNext(){…}

public E next(){…}

public void remove(){…}

}

Implementera konstruktorn och alla metoderna i LimitedHeapIterator. Observera att

en iterator inte behöver ge oss elementen i någon viss ordning.


Uppgift 3 (7 p)

a) Definiera ett binärt sökträd.

b) Hur definieras att ett binärt sökträd är balanserat?

c) Antag att vi har ett binärt sökträd som ser ut enligt följande (A, B och C är underträd):

Y

X

C

A

B

Antag att höjden för B och C är n och höjden för A är n+1. Visa hur man kan balansera detta

träd genom att använda enkelrotation (single rotation). Bevisa också att det träd som man

får som resultat av enkelrotationen fortfarande är ett binärt sökträd.

d) Man kan gå igenom elementen i ett binärt sökträd i preorder, inorder eller postorder. Ange i

vilken ordning man besöker noderna i följande träd när man använder var och en av dessa

metoder:

1

2 3

4 5 6 7


Uppgift 4 (7 p)

Klassen Element ser ut så här:

public class Element {

private int id;

public Element(int id) { this.id = id; }

public int hashCode() { return id; }

}

Vi vill lagra elementen i en hashtabell .

a) Vi använder en hashtabell som implementerats med hjälp av en vektor med linjär teknik.

Vektorn har 11 element. Antag att man sätter in element med värdena 3, 7, 14, 8, 22, 5, 30

och 11 (i den ordningen). Hashtabellen är tom innan vi börjar sätta in talen. Visa på vilka

platser i vektorn som elementen hamnar.

b) Antag att man i stället använder kvadratisk teknik. Var hamnar då elementen i den

föregående uppgiften?

c) Antag att myTalble är av klassen Hashtable från java.util (se utdelade blad). Antag att

hashtabellen innehåller de element som finns i a) ovan. Vi skriver följande kod:

Element u = new Element(7);

boolean isInTable = myTable.contains(u);

Det visar sig att isInTable får värdet false. Förklara detta! Beskriv också hur man kan göra

för att få vettiga resultat.

d) Beskriv hur en öppen hashtabell fungerar och hur kollisioner hanteras i en sådan.

Uppgift 5 (7 p)

a) Skriv en rekursiv metod för att beräkna produkten av två positiva tal där man använder att

n*m = n + n*(m-1). I metoden får enbart de aritmetiska operationerna addition och

subtraktion användas! Loopar får heller inte användas!

b) Vi har ett binärt träd där noderna ser ut så här:

public class Node{

Node left;

Node right;

int value; // Ett värde som finns i alla noder

}

och där trädklassen ser ut så här:

public class BinaryTreeUnsorted{

Node root;

// En massa andra attribut kan finns här!

}

Skriv en rekursiv metod numberOfNodes som tar reda på hur många noder det finns i

trädet.

c) För trädet i b, skriv en rekursiv metod product som beräknar produkten alla value som

finns i trädet.

More magazines by this user
Similar magazines