Föreläsning 2
Datastrukturer
Abstrakta datastrukturer
Stack
Stack implementerad med array
Länkad lista
Stack implementerad med länkad lista
Inlämningsuppgifter
Datastrukturer
En datastruktur är en struktur som organiserar
data
Ett elementärt exempel är en array i C
Val av datastruktur ska göras så att vi effektivt
kan lagra, organisera och processa data
För vissa problem är val av rätt datastruktur mer
än halva lösningen!
Abstrakta datastrukturer
Exempel på datastrukturer:
stack, kö, lista, prioritetskö, träd, graf
array, länkad lista, heap
(-ADT)
(-implementeringar)
En abstrakta datastruktur (ADT-abstract data type)
definieras via operationerna som kan utföras utan
att diskutera implementation
En stack kan definieras via push (som lägger ett element överst
i stacken) och pop (som returnerar översta elementet i
stacken)
En stack kan implementeras med en array eller en länkad lista
Det finns flera möjliga definitioner av tex en stack-ADT
Stack (ADT)
En stack fungerar som en hög. Man fyller på överst
och man tar bort överst.
LIFO-Last In First Out.
push(element) - lägger element överst i stacken
pop() – avlägsnar och returnerar översta
elementet (ibland pull)
Möjliga operationer:
initStack() / freeStack(stack)
isEmpty() – returnerar true om stacken är tom
isFull() - returnerar true om stacken är full
peek() - returnerar översta elementet (utan att
avlägsna det)
Stack implementerad med array
stack.h:
stack.c:
void push(char c);
#include "stack.h"
char pop();
#define SIZE 30
int isEmpty();
static char stack[SIZE];
static int nrElements = 0;
main.c:
void push(char c){
#include <stdio.h>
stack[nrElements]=c;
#include <stdlib.h>
nrElements++;
#include "stack.h"
int main(){
}
push('h');
char pop(){
push('e');
return stack[--nrElements];
push('j');
}
while(!isEmpty())
int isEmpty(){
printf("%c,",pop());
return nrElements == 0;
return 0;
}
}
Saknar skydd! Om vi behöver 2 stackar?
Flera stackar
stackArray.c:
#include <stdlib.h>
#include <assert.h>
#include "stackArray.h"
Stack* initStack(){
Stack *sp = (Stack*)malloc(sizeof(Stack));
sp->nrElements=0;
return sp;
}
void push(Stack *sp, int element){
assert(sp->nrElements<MAXSTACK);
sp->array[sp->nrElements]=element;
++(sp->nrElements);
}
int pop(Stack *sp){
assert(!isEmpty(sp));
--(sp->nrElements);
return sp->array[sp->nrElements];
}
…
stackArray.h:
#define MAXSTACK 20
typedef struct{
int nrElements;
int array[MAXSTACK];
} Stack;
Stack* initStack();
void push(Stack *sp, int element);
int pop(Stack *sp);
…
main.c:
Stack *s1 = initStack();
Stack *s2 = initStack();
int i;
for(i=0;i<10;i++) push(s1,i);
for(i=0;i<10;i++) push(s2,pop(s1));
for(i=0;i<10;i++)
printf("Element: %d \n",pop(s2));
freeStack(s1);
freeStack(s2);
Länkad lista (enkellänkad)
En länkad lista är en datastruktur där varje
första
element ligger i en nod som håller reda på
nästa nod. Det enda man behöver är den
första noden.
Fördelarna med denna struktur jämfört med
ett fält är att den kan växa dynamiskt och
att det är effektivt att stoppa in eller ta ut
element mitt i. Man behöver inte flytta
massor med element utan bara ändra
länkarna.
Data1
Data2
Data3
Data4
första
Data1
Lägga till data på godtycklig plats:
Data2
Data3
Data4
Data3
Data4
Ny data
första
Data1
Ta bort data:
Data2
Stack implementerad som länkad lista
main.c:
#include <stdio.h>
#include "stackLink.h"
int main(){
int i;
for(i=0;i<10;i++){
push('a'+i);
}
while(!isEmpty())
printf("%c\n",pop());
return 0;
}
stackLink.c:
#include <stdlib.h>
#include "stackLink.h"
typedef struct node node;
node *top=NULL;
struct node{
char element;
node *next;
};
void push(char c){
node *newNode = (node *)malloc(sizeof(node));
newNode ->element = c;
stackLink.h:
newNode ->next=top;
void push(char c);
top= newNode;
char pop();
}
int isEmpty();
stack.c:
…
char pop(){
char c = top->element;
node *newNode =top;
top = top->next;
free(newNode);
return c;
}
int isEmpty(){
return top==NULL;
}
Flera stackar
stackLink.c:
stackLink.h:
#include <stdlib.h>
typedef struct node Node;
#include <assert.h>
struct node{
#include "stackLink.h"
int element;
Stack* initStack(){
Node *next;
Stack *sp = (Stack*)malloc(sizeof(Stack));
};
sp->top=NULL;
typedef struct{
return sp;
Node *top;
}
}Stack;
void push(Stack *sp, int element){
Stack* initStack();
Node *newNode = (Node*)malloc(sizeof(Node)); void push(Stack *sp, int element);
newNode->element=element;
int pop(Stack *sp);
newNode->next=sp->top;
…
sp->top=newNode;
}
main.c:
int pop(Stack *sp){
Stack *s1 = initStack();
assert(!isEmpty(sp));
Stack *s2 = initStack();
int element = sp->top->element;
int i;
Node *temp = sp->top;
for(i=0;i<10;i++) push(s1,i);
sp->top = sp->top->next;
for(i=0;i<10;i++) push(s2,pop(s1));
free(temp);
for(i=0;i<10;i++)
return element;
printf("Element: %d \n",pop(s2));
}
freeStack(s1);
…
freeStack(s2);
Inlämningsuppgifter
Följande uppgifter redovisas senast måndag
den 28 januari och kan inte redovisas senare:
2A, 2B, 2.2, 2.C
Dessa uppgifter bör göras nu för att ni ska kunna
följa kursen på ett bra sätt. Övriga kan ni göra
vid tillfälle för högre betyg.
Uppgifter ej i boken
2.A
Implementera en stack för decimaltal mha en array. Använd separata filer:
stack.c, stack.h, main.c. Stacken ska ha funktionerna push, pop, peek,
isEmpty, isFull, initStack och freeStack. Den ska allokera minne för stacken
dynamiskt (dvs som på föreläsningen, ejdynamisk storlek på arrayen). Skriv
ett eget testprogram i main som testar att allt verkar fungera. Se till att du lär
dig att kompilera projekt med flera filer i codeblocks.
(2p)
2.B
Implementera en stack för strängar mha länkade listor. Använd separata
filer. Skriv ett program i main som läser in 10 ord från användaren och lagrar
dessa i stacken. Sedan ska programmet skriva ut alla ord i stacken.
TIPS: Skapa en struct som innehåller en sträng (char-array).
(2p)
2.C
Gör exempel 2.1 i boken.
(3p)
