Algoritmer och datastrukturer

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 stack[nrElements]=c; #include 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 #include #include "stackArray.h" Stack* initStack(){ Stack *sp = (Stack*)malloc(sizeof(Stack)); sp->nrElements=0; return sp; } void push(Stack *sp, int element){ assert(sp->nrElementsarray[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;inext; free(newNode); return c; } int isEmpty(){ return top==NULL; }

Flera stackar

stackLink.c: stackLink.h: #include typedef struct node Node; #include 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;itop = sp->top->next; for(i=0;i