1. No category

Akademin för innovation, design och teknik
Caroline Uppsäll
1(5)
Datastrukturer,algoritmerochprogramkonstruktion
DVA104,HT2015
Laboration2–Lista&Kö
Tänk igenom och diskutera ADT:n innan ni börjar implementera! Glöm inte att skriva
ner precondition, postcondition, returvärde och övrig viktig information som
kommentar i koden.
Uppgift 1 – ADT Länkad Lista
Ni ska i den här labben bygga en länkad lista. Om den är enkellänkad eller dubbellänkad
bestämmer ni själva, ni bestämmer också om den ska ha referens endast till första
noden (header) eller om det också ska finnas referens till sista noden (tail).
Ni ska skapa en nod (strukt), datat som lagras i noden kan vara ett heltal, samt alla de
funktioner som behövs för att hantera noden och listan. Listan ska kunna bestå av
godtyckligt många element av den nod ni skapat.
Det ni ska kunna göra med List-ADT:n är minst följande:
•
•
•
•
•
•
Lägga till en ny nod någonstans i listan. Man ska kunna lägga till den nya noden
först, sist eller mitt i listan baserat på t.ex. data eller ordning (ni bestämmer
själva på vilket sätt man väljer plats mitt i listan). Fundera på om detta bör
delas upp på tre funktioner.
Ta bort någon nod i listan. Man ska kunna ta bort den första noden, den sista
noden eller en nod mitt i listan baserat på t.ex. data eller ordning (ni bestämmer
själva på vilket sätt man väljer plats mitt i listan) . Består listan av endast en nod
ska man självklart kunna ta bort även den. Är listan tom kan det vara en bra idé
att meddela användaren om detta. Fundera på om detta bör delas upp på tre
funktioner.
Skriv ut hela listan från början till slut.
Sök efter ett visst data i listan. Om funktionen endast ska returnera huruvida
datat finns eller inte eller om den eftersökta noden ska returneras bestämmer ni
själva.
Tömma hela listan (om man t.ex vill börja bygga på en ny så ska man kunna
göra det utan att starta om programmet).
Avsluta programmet.
Finns det fler operationer ni vill kunna göra med er länkade listan så får ni självklart
implementera funktioner för det också.
Se till så att programmet är väl strukturerat och att ni väljer bra namn på variabler och
funktioner samt ser till att kommentera koden så att den blir lättläst.
Glöm inte att göra ett huvudprogram med en meny så att ni kan testa er lista ordentligt.
Projektet ska bestå av en h-fil innehållande listans interface, minst en c-fil innehållande
listans kod samt en c-fil innehållande huvudprogrammet.
Akademin för innovation, design och teknik
Caroline Uppsäll
2(5)
Diskutera gärna er planerade lösning med labbassen eller läraren innan ni börjar
implementera.
Längst ner i denna labbspec finns ett exempel på hur listans interface kan se ut. Exakt
hur listans strukter samt funktioner ser ut beror självklart på vilken typ av listan man
väljer att göra samt hur man väljer att implementera sina funktioner.
Glöm inte att återlämna dynamiskt allokerat minne!
Uppgift 2 – ADT Kö, FIFO
Ni ska nu göra en Kö-ADT genom att återanvända er länkade lista från uppgift 1. Kön
ska alltså i bakgrunden vara en länkad lista men med begränsade operationer. Håll i
åtanke att återanvända inte är detsamma som att kopiera, kopiera får ni inte göra.
Den kö ni ska göra en ADT för är en FIFO kö så tänk på vilken funktionalitet en sådan
ska ha.
Kön ska ha kapacitet för godtyckligt många köelement.
Glöm inte att göra ett huvudprogram med en meny så att ni kan testa er kö ordentligt.
Precis som listan ska kön bestå av minst tre filer (även listans c och h-fil måste
inkluderas i projektet för kön).
Diskutera gärna er planerade lösning med labbassen eller läraren innan ni börjar
implementera.
Exempel på hur interfacet för kön kan se ut:
/*Då kön ska återanvända listan måste denna vara inkluderad (så
att kön har tillgång till listans funktioner)/*
#include "LinkedList.h"
#ifndef projektnamn_filnamn_h
#define projektnamn_filnamn_h
/*Kön är i bakgrunden en länkad lista = återanvändning*/
typedef struct Queue{
List *queue;
}Queue;
/*Allokerar dynamiskt minne för en kö.
Retur - den skapade kön eller NULL om minne inte gick att
allokera*/
Queue *createQueue();
/*Lägger till nod innehållande value först i kön - enligt FIFO*/
void addToQueue(Queue *myQueue, int value);
/*Tar bort den sista noden - enligt FIFO*/
void removeFromQueue(Queue *myQueue);
/*skriver ut hela kön*/
void printQueue(Queue *myQueue);
/*Returnerar antal noder i kön*/
int noOfNodesInQueue(Queue *myQueue);
/*Frigör minnet för samtliga noder i kön*/
Akademin för innovation, design och teknik
Caroline Uppsäll
3(5)
void emptyQueue(Queue *myQueue);
/*Frigör minnet för samtliga noder i kön samt minnet för själva
kön*/
void destroyQueue(Queue *myQueue);
#endif
Exempel på återanvändning av listan i kön (c-filen).
/*Tar bort den sista noden - enligt FIFO*/
void removeFromQueue(Queue *myQueue)
{
removeLast(myQueue->queue); /*anropa funktionen i listan som
tar bort sist*/
}
Redovisning
Samtliga uppgifter ska redovisas muntligt under ett och samma redovisningstillfälle
genom att visa fungerande implementationer till labbassistenten.
Om samtliga laborationer redovisats och godkänts innan tentamen erhålls bonuspoäng
på denna. Tänk dock på att redovisa labbarna utspridda under hela kursens gång då det
troligtvis inte finns tid om alla ska redovisas på slutet.
Akademin för innovation, design och teknik
Caroline Uppsäll
4(5)
Exempel på hur interfacet för listan kan se ut:
följande funktioner är iterativa.
#ifndef projektnamn_filnamn_h
#define projektnamn_filnamn_h
/*Noden
- Detta är en nod i en enkellänkad listan, det går givetvis
även bra att göra en dubbellänkad lista, (vissa funktioner
blir kan då bli annorlunda)*/
typedef struct Node{
int data;
struct Node *next;
}Node;
/*Listan
- kan även innehålla tail (vissa funktionerna kan då bli
annorlunda)
- kan även innehålla en räknare som räknar antal noder*/
typedef struct List{
Node *head;
}List;
/*Allokerar minne för en lista.
Retur - en pekare till den nya Lista om allokering lyckades
NULL om allokering inte lyckades*/
List *createList();
/*Allokerar minne för en nod samt lägger value i datafältet,
sätter next till null
Retur - en pekare till den nya noden om allokering lyckades
NULL om allokering inte lyckades*/
Node *createNode(int value);
/*Returnerar antal noder i listan*/
int noOfNodesInList(List *myList);
/*Lägger till en nod först i listan
pre - den nya noden är skapad (självklart kan man även välja
att skapa den nya noden inne i funktionen).
post - listan pekar på den nya noden, den nya noden pekar på
resten av listan*/
void addNewNodeFirst(List *myList, Node *newNode);
/*Lägger till en nod sist i listan
pre - den nya noden är skapad (självklart kan man även välja
att skapa den nya noden inne i funktionen).
post - den nya noden har lagts till sist i listan, om listan
är tom läggs den till vid listans början*/
void addNewNodeLast(List *myList, Node *newNode);
/*Lägger till en nod efter noden innehållande value (går
självklart även att göra på position)
Pre - den nya noden är skapad (självklart kan man även välja
att skapa den nya noden inne i funktionen).
Post - den nya noden har lagts till efter noden innehållande
value.
Vad händer om value inte finns i listan eller om listan är
tom?*/
void addNewNodeAfter(List *myList, Node *newNode, int value);
Akademin för innovation, design och teknik
Caroline Uppsäll
5(5)
/*skriver ut hela listan. Om ingen lista finns skrivs det ut*/
void printList(List *myList);
/*Tar bort den första noden i listan
Pre - listan är inte tom
Post - listan pekar på den andra noden
den tidigare första noden är borttagen och minnet
frigjort*/
void removeFirst(List *myList);
/*Tar bort den sista noden i listan
Pre - listan är inte tom
Post - nextpekaren i den näst sista noden är satt till NULL
den tidigare sista noden är borttagen och minnet
frigjort*/
void removeLast(List *myList);
/*Tar bort noden innehållande value (går självklart även att
göra på position)
Pre - listan är inte tom och det finns en nod innehållande
value i listan
Post - noden innehållande value är borttagen*/
void removeNode(List *myList, int value);
/*Tar bort och frigör minne för alla noder i listan. Sätter
listans huvud till NULL*/
void emptyList(List *myList);
/*Tar bort och frigör minne för listan*/
void destroyList(List *myList);
/*Söker efter x i listan
Retur – 1 om x finns i listan, annars 0. (Man kan också tänka
sig att returnera t.ex den funna noden, positionen eller
liknande. */
int search (Node *myNode, int x);
#endif