Implementieren Sie die Header Datei für Array basierte Listen. Sie können dabei jeweils die aus der Javaaufgabe bekannten Lösungen anpassen.
- E alGet(AL this, int i);
Holt das i-te Elemente der Liste.
- void alRemove(AL* this, int i);
Das Element am übergebenen Index soll gelöscht werden, sofern dieser Index existiert. Die Liste wird um 1 kürzer und alle nachfolgenden Elemente rutschen in der Liste eine Position nach vorne.
- void alAddAll(AL* this, AL that);
Alle Elemente der übergenenen Liste sollen in die Liste hinten hinzugefügt werden.
- bool alContainsWith(AL this,Predicate pred);
Ist genau dann wahr, wenn ein Element das übergebene Prädikat erfüllt.
- AL alSublist(AL this, int i, int l);
Eine neue Teilliste dieser Liste. Die neue Liste habe die Länge l und besteht aus den Elementen ab Index i von dieser Liste. Ist l zu lang, sor wird eine kürzere Teilliste erzeugt.
- bool alStartsWith(AL this,AL that,EQ eq);
Genau dann wahr, wenn die übergebene Liste ein Präfix dieser Liste ist.
- bool alEndsWith(AL this,AL that,EQ eq);
Genau dann wahr, wenn die übergebene Liste eine Endliste dieser Liste ist.
- void alReverse(AL* this);
Ändert die Reihenfolge der Liste, indem diese umgedreht wird.
- void alInsert(AL* this,int i, E e);
Das Element soll an dem übergebenen Index eingefügt werden. Ist der Index zu groß, wird am Ende der Liste eingefügt. Ist der Index negativ, so ändert sich die Liste nicht.
- void alSortBy(AL* this,Comparator cmp);
Die Liste wird sortiert. Als Sortierfunktion wird der übergenen Komperator verwendet. Sie können hierzu im Internet nach dem Bubble-Sort Algorithmus suchen, der mit Hilfe zweier Schleifen mehrfach über die Liste geht und benachbarte Element tauscht, falls die in falscher Reihenfolge stehen.
#include "AL.h"
#include <stdlib.h>
AL alNew(){
AL this;
this.size = 0;
this.capacity = 5;
this.store = (E*)malloc(this.capacity*sizeof(E));
return this;
}
void alDelete(AL this){
free(this.store);
}
void alAdd(AL* this, E e){
if (this->size>=this->capacity){
alEnlargeStore(this);
}
this->store[this->size++] = e;
}
void alEnlargeStore(AL* this){
E* newStore = (E*)malloc((5+this->capacity)*sizeof(E));
unsigned int i;
for (i=0;i<this->capacity;i++) newStore[i] = this->store[i];
this->capacity += 5;
free(this->store);
this->store = newStore;
}
void alForEach(AL this, void f(E)){
unsigned int i;
for (i=0;i<this.size;i++) f(this.store[i]);
}
E alFold(AL this, E start, void op(E,E)){
unsigned int i;
for (i=0;i<this.size;i++)
op(start,this.store[i]);
return start;
}
E alGet(AL this, int i) {
}
void alRemove(AL* this, int i) {
}
void alAddAll(AL* this, AL that) {
}
bool alContainsWith(AL this,Predicate pred) {
}
AL alSublist(AL this, int i, int l) {
}
bool alStartsWith(AL this,AL that,EQ eq) {
}
bool alEndsWith(AL this,AL that,EQ eq) {
}
void alReverse(AL* this) {
}
void alInsert(AL* this,int i, E e) {
}
void alSortBy(AL* this,Comparator cmp) {
}
Subato
