├── list ├── char │ ├── examples │ │ ├── load_example_01.txt │ │ ├── CMakeLists.txt │ │ ├── load.c │ │ ├── copy.c │ │ ├── insert_ord.c │ │ ├── iterate.c │ │ └── additional_op.c │ └── homepage.h ├── int │ ├── examples │ │ ├── load_example_01.txt │ │ ├── CMakeLists.txt │ │ ├── load.c │ │ ├── copy.c │ │ ├── insert_ord.c │ │ ├── iterate.c │ │ └── additional_op.c │ └── homepage.h ├── point2d │ ├── examples │ │ ├── CMakeLists.txt │ │ └── show.c │ └── homepage.h ├── int_vector │ ├── examples │ │ ├── CMakeLists.txt │ │ └── show.c │ └── homepage.h ├── list.c └── list.h ├── scripts ├── conf_elemtype.txt ├── conf_datastruct.txt ├── conf_complete.txt └── generate_doc.sh ├── doublelist ├── int │ ├── examples │ │ ├── load_example_01.txt │ │ ├── CMakeLists.txt │ │ ├── load.c │ │ ├── insert_ord.c │ │ ├── copy.c │ │ └── iterate.c │ └── homepage.h ├── doublelist.c └── doublelist.h ├── doc ├── logo │ ├── logo.png │ ├── favicon.png │ ├── logo_big.png │ └── model.pptx └── utils │ ├── header.html │ ├── DoxygenLayout.xml │ └── DoxygenLayoutNoHome.xml ├── tree ├── int │ ├── examples │ │ ├── CMakeLists.txt │ │ ├── tree_from_vector.c │ │ └── insert_ord.c │ └── homepage.h ├── char │ └── homepage.h ├── tree.c └── tree.h ├── maxheap ├── int │ ├── examples │ │ ├── CMakeLists.txt │ │ ├── insert_node.c │ │ ├── heapify.c │ │ └── heapsort.c │ └── homepage.h ├── maxheap.c └── maxheap.h ├── minheap ├── int │ ├── examples │ │ ├── CMakeLists.txt │ │ ├── insert_node.c │ │ ├── heapify.c │ │ └── heapsort.c │ └── homepage.h ├── minheap.c └── minheap.h ├── AUTHORS ├── CMakeLists.examples.inc.txt ├── elemtype ├── point2d │ ├── elemtype.c │ └── elemtype.h ├── char │ ├── elemtype.c │ └── elemtype.h ├── int │ ├── elemtype.c │ └── elemtype.h └── int_vector │ ├── elemtype.c │ └── elemtype.h ├── .github └── workflows │ └── doc.yml ├── LICENSE ├── CMakeLists.txt ├── .gitignore └── README.md /list/char/examples/load_example_01.txt: -------------------------------------------------------------------------------- 1 | a b d e ' f $ -------------------------------------------------------------------------------- /list/int/examples/load_example_01.txt: -------------------------------------------------------------------------------- 1 | 0 12 3 4 2 34 -------------------------------------------------------------------------------- /scripts/conf_elemtype.txt: -------------------------------------------------------------------------------- 1 | int char int_vector point2d -------------------------------------------------------------------------------- /doublelist/int/examples/load_example_01.txt: -------------------------------------------------------------------------------- 1 | 0 12 3 4 2 34 -------------------------------------------------------------------------------- /scripts/conf_datastruct.txt: -------------------------------------------------------------------------------- 1 | doublelist list tree minheap maxheap -------------------------------------------------------------------------------- /doc/logo/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/prittt/fondamenti-ii/HEAD/doc/logo/logo.png -------------------------------------------------------------------------------- /doc/logo/favicon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/prittt/fondamenti-ii/HEAD/doc/logo/favicon.png -------------------------------------------------------------------------------- /doc/logo/logo_big.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/prittt/fondamenti-ii/HEAD/doc/logo/logo_big.png -------------------------------------------------------------------------------- /doc/logo/model.pptx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/prittt/fondamenti-ii/HEAD/doc/logo/model.pptx -------------------------------------------------------------------------------- /list/point2d/examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(examples_sources 2 | show.c 3 | ) 4 | include(../../../CMakeLists.examples.inc.txt) -------------------------------------------------------------------------------- /list/int_vector/examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(examples_sources 2 | show.c 3 | ) 4 | include(../../../CMakeLists.examples.inc.txt) -------------------------------------------------------------------------------- /scripts/conf_complete.txt: -------------------------------------------------------------------------------- 1 | doublelist/int list/char list/int list/int_vector list/point2d tree/int tree/char minheap/int maxheap/int -------------------------------------------------------------------------------- /tree/int/examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(examples_sources 2 | tree_from_vector.c 3 | insert_ord.c 4 | ) 5 | include(../../../CMakeLists.examples.inc.txt) -------------------------------------------------------------------------------- /maxheap/int/examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(examples_sources 2 | insert_node.c 3 | heapify.c 4 | heapsort.c 5 | ) 6 | include(../../../CMakeLists.examples.inc.txt) -------------------------------------------------------------------------------- /minheap/int/examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(examples_sources 2 | insert_node.c 3 | heapify.c 4 | heapsort.c 5 | ) 6 | include(../../../CMakeLists.examples.inc.txt) -------------------------------------------------------------------------------- /doublelist/int/examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(examples_sources 2 | insert_ord.c 3 | iterate.c 4 | load.c 5 | copy.c 6 | ) 7 | include(../../../CMakeLists.examples.inc.txt) -------------------------------------------------------------------------------- /list/char/examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(examples_sources 2 | insert_ord.c 3 | iterate.c 4 | additional_op.c 5 | load.c 6 | copy.c 7 | ) 8 | include(../../../CMakeLists.examples.inc.txt) -------------------------------------------------------------------------------- /list/int/examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(examples_sources 2 | insert_ord.c 3 | iterate.c 4 | additional_op.c 5 | load.c 6 | copy.c 7 | ) 8 | include(../../../CMakeLists.examples.inc.txt) -------------------------------------------------------------------------------- /AUTHORS: -------------------------------------------------------------------------------- 1 | Copyright (c) 2020 - 2021, Federico Bolelli 2 | 3 | Moral rights: 4 | Federico Bolelli 5 | 6 | The version control system provides attribution for specific lines of code. -------------------------------------------------------------------------------- /list/int/homepage.h: -------------------------------------------------------------------------------- 1 | /** 2 | @mainpage Liste di `int` 3 | 4 | In questa pagina trovi la documentazione per liste di `int`. In particolare: 5 | 6 | - \ref elemtype.h contiene la definizione di `ElemType` per il tipo `int` 7 | e la documentazione delle funzioni a esso associate; 8 | - \ref list.h contiene la definizione del tipo `Item` e la documentazione delle 9 | funzioni primitive (e non) relative alle liste. Si noti che il comportamento di 10 | queste funzioni è indipendente dalla definizione di `ElemType`. 11 | */ -------------------------------------------------------------------------------- /list/char/homepage.h: -------------------------------------------------------------------------------- 1 | /** 2 | @mainpage Liste di `char` 3 | 4 | In questa pagina trovi la documentazione per liste di `char`. In particolare: 5 | 6 | - \ref elemtype.h contiene la definizione di `ElemType` per il tipo `char` 7 | e la documentazione delle funzioni a esso associate; 8 | - \ref list.h contiene la definizione del tipo `Item` e la documentazione delle 9 | funzioni primitive (e non) relative alle liste. Si noti che il comportamento di 10 | queste funzioni è indipendente dalla definizione di `ElemType`. 11 | */ -------------------------------------------------------------------------------- /list/point2d/homepage.h: -------------------------------------------------------------------------------- 1 | /** 2 | @mainpage Liste di `Punto 2D` 3 | 4 | In questa pagina trovi la documentazione per liste di `Punto 2D`. In particolare: 5 | 6 | - \ref elemtype.h contiene la definizione di `ElemType` per il tipo `Punto` 7 | e la documentazione delle funzioni a esso associate; 8 | - \ref list.h contiene la definizione del tipo `Item` e la documentazione delle 9 | funzioni primitive (e non) relative alle liste. Si noti che il comportamento di 10 | queste funzioni è indipendente dalla definizione di `ElemType`. 11 | */ -------------------------------------------------------------------------------- /tree/char/homepage.h: -------------------------------------------------------------------------------- 1 | /** 2 | @mainpage Alberi di `char` 3 | 4 | In questa pagina trovi la documentazione per alberi binari di `char`. In particolare: 5 | 6 | - \ref elemtype.h contiene la definizione di `ElemType` per il tipo `char` 7 | e la documentazione delle funzioni a esso associate; 8 | - \ref tree.h contiene la definizione del tipo `Node` e la documentazione delle 9 | funzioni primitive (e non) relative agli alberi binari. Si noti che il comportamento di 10 | queste funzioni è indipendente dalla definizione di `ElemType`. 11 | */ -------------------------------------------------------------------------------- /tree/int/homepage.h: -------------------------------------------------------------------------------- 1 | /** 2 | @mainpage Alberi di `int` 3 | 4 | In questa pagina trovi la documentazione per alberi binari di `int`. In particolare: 5 | 6 | - \ref elemtype.h contiene la definizione di `ElemType` per il tipo `int` 7 | e la documentazione delle funzioni a esso associate; 8 | - \ref tree.h contiene la definizione del tipo `Node` e la documentazione delle 9 | funzioni primitive (e non) relative agli alberi binari. Si noti che il comportamento di 10 | queste funzioni è indipendente dalla definizione di `ElemType`. 11 | */ -------------------------------------------------------------------------------- /list/int_vector/homepage.h: -------------------------------------------------------------------------------- 1 | /** 2 | @mainpage Liste di `int vector` 3 | 4 | In questa pagina trovi la documentazione per liste di `int vector`. In particolare: 5 | 6 | - \ref elemtype.h contiene la definizione di `ElemType` per il tipo `int vector` 7 | e la documentazione delle funzioni a esso associate; 8 | - \ref list.h contiene la definizione del tipo `Item` e la documentazione delle 9 | funzioni primitive (e non) relative alle liste. Si noti che il comportamento di 10 | queste funzioni è indipendente dalla definizione di `ElemType`. 11 | */ -------------------------------------------------------------------------------- /maxheap/int/homepage.h: -------------------------------------------------------------------------------- 1 | /** 2 | @mainpage Max-Heap di `int` 3 | 4 | In questa pagina trovi la documentazione per code di priorità (max-heap) di `int`. In particolare: 5 | 6 | - \ref elemtype.h contiene la definizione di `ElemType` per il tipo `int` 7 | e la documentazione delle funzioni a esso associate; 8 | - \ref maxheap.h contiene la definizione del tipo `Heap` e la documentazione delle 9 | funzioni primitive (e non) relative alle code di priorità (max-heap). Si noti che 10 | il comportamento di queste funzioni è indipendente dalla definizione di `ElemType`. 11 | */ -------------------------------------------------------------------------------- /minheap/int/homepage.h: -------------------------------------------------------------------------------- 1 | /** 2 | @mainpage Min-Heap di `int` 3 | 4 | In questa pagina trovi la documentazione per code di priorità (min-heap) di `int`. In particolare: 5 | 6 | - \ref elemtype.h contiene la definizione di `ElemType` per il tipo `int` 7 | e la documentazione delle funzioni a esso associate; 8 | - \ref minheap.h contiene la definizione del tipo `Heap` e la documentazione delle 9 | funzioni primitive (e non) relative alle code di priorità (min-heap). Si noti che 10 | il comportamento di queste funzioni è indipendente dalla definizione di `ElemType`. 11 | */ -------------------------------------------------------------------------------- /doublelist/int/homepage.h: -------------------------------------------------------------------------------- 1 | /** 2 | @mainpage Liste Doppiamente Concatenate (Doubly Linked List) di `int` 3 | 4 | In questa pagina trovi la documentazione per liste doppiamente concatenate di `int`. In particolare: 5 | 6 | - \ref elemtype.h contiene la definizione di `ElemType` per il tipo `int` 7 | e la documentazione delle funzioni a esso associate; 8 | - \ref doublelist.h contiene la definizione del tipo `Item` e la documentazione delle 9 | funzioni primitive (e non) relative alle liste. Si noti che il comportamento di 10 | queste funzioni è indipendente dalla definizione di `ElemType`. 11 | */ -------------------------------------------------------------------------------- /CMakeLists.examples.inc.txt: -------------------------------------------------------------------------------- 1 | FOREACH(cur_file ${examples_sources}) 2 | get_filename_component(exe_name ${cur_file} NAME_WE) 3 | file(GLOB test_files ${exe_name}*.txt ) 4 | FOREACH(f ${test_files}) 5 | get_filename_component(f_name ${f} NAME) 6 | configure_file(${f} ${CMAKE_CURRENT_BINARY_DIR}/${f_name} COPYONLY) 7 | ENDFOREACH() 8 | 9 | set(exe_name "${target_name_uppercase}_${exe_name}") 10 | 11 | add_executable(${exe_name} ${cur_file} ${test_files}) 12 | 13 | set_target_properties(${exe_name} PROPERTIES FOLDER "${cur_folder}/examples") 14 | target_link_libraries(${exe_name} ${target_name_uppercase}) 15 | ENDFOREACH() -------------------------------------------------------------------------------- /maxheap/int/examples/insert_node.c: -------------------------------------------------------------------------------- 1 | /** @example insert_node.c 2 | * In questo esempio si mostra come aggiungere un nuovo elemento a una coda di 3 | * priorità, garantendo che le proprietà (min-)heap siano rispettate. 4 | */ 5 | #include 6 | 7 | #include "maxheap.h" 8 | 9 | int main(void) { 10 | ElemType v[] = { 0, 12, 4, 21, 2, 5, 18, 77, 8, -1 }; 11 | size_t v_size = sizeof(v) / sizeof(ElemType); 12 | 13 | Heap* h = HeapCreateEmpty(); 14 | for (unsigned i = 0; i < v_size; ++i) { 15 | HeapMaxInsertNode(h, &v[i]); 16 | } 17 | HeapWriteStdout(h); 18 | 19 | HeapDelete(h); 20 | 21 | return EXIT_SUCCESS; 22 | } -------------------------------------------------------------------------------- /minheap/int/examples/insert_node.c: -------------------------------------------------------------------------------- 1 | /** @example insert_node.c 2 | * In questo esempio si mostra come aggiungere un nuovo elemento a una coda di 3 | * priorità, garantendo che le proprietà (min-)heap siano rispettate. 4 | */ 5 | #include 6 | 7 | #include "minheap.h" 8 | 9 | int main(void) { 10 | ElemType v[] = { 0, 12, 4, 21, 2, 5, 18, 77, 8, -1 }; 11 | size_t v_size = sizeof(v) / sizeof(ElemType); 12 | 13 | Heap* h = HeapCreateEmpty(); 14 | for (unsigned i = 0; i < v_size; ++i) { 15 | HeapMinInsertNode(h, &v[i]); 16 | } 17 | HeapWriteStdout(h); 18 | 19 | HeapDelete(h); 20 | 21 | return EXIT_SUCCESS; 22 | } -------------------------------------------------------------------------------- /list/char/examples/load.c: -------------------------------------------------------------------------------- 1 | /** @example load.c 2 | * In questo esempio si mostra come creare una lista con elementi letti da file. 3 | */ 4 | #define _CRT_SECURE_NO_WARNINGS 5 | #include "list.h" 6 | 7 | #include 8 | 9 | Item *ListLoad(const char *filename) { 10 | FILE *f; 11 | f = fopen(filename, "r"); 12 | 13 | if (!f) { 14 | return NULL; 15 | } 16 | 17 | Item *i = ListCreateEmpty(); 18 | while (1) { 19 | ElemType tmp; 20 | if (1 != ElemRead(f, &tmp)) { 21 | break; 22 | } 23 | i = ListInsertHead(&tmp, i); 24 | } 25 | 26 | fclose(f); 27 | return i; 28 | } 29 | 30 | int main(void) { 31 | Item *list = ListLoad("load_example_01.txt"); 32 | 33 | ListWriteStdout(list); 34 | 35 | ListDelete(list); 36 | 37 | return EXIT_SUCCESS; 38 | } 39 | 40 | -------------------------------------------------------------------------------- /list/int/examples/load.c: -------------------------------------------------------------------------------- 1 | /** @example load.c 2 | * In questo esempio si mostra come creare una lista con elementi letti da file. 3 | */ 4 | #define _CRT_SECURE_NO_WARNINGS 5 | #include "list.h" 6 | 7 | #include 8 | 9 | Item *ListLoad(const char *filename) { 10 | FILE *f; 11 | f = fopen(filename, "r"); 12 | 13 | if (!f) { 14 | return NULL; 15 | } 16 | 17 | Item *i = ListCreateEmpty(); 18 | while (1) { 19 | ElemType tmp; 20 | if (1 != ElemRead(f, &tmp)) { 21 | break; 22 | } 23 | i = ListInsertHead(&tmp, i); 24 | } 25 | 26 | fclose(f); 27 | return i; 28 | } 29 | 30 | int main(void) { 31 | Item *list = ListLoad("load_example_01.txt"); 32 | 33 | ListWriteStdout(list); 34 | 35 | ListDelete(list); 36 | 37 | return EXIT_SUCCESS; 38 | } 39 | 40 | -------------------------------------------------------------------------------- /doublelist/int/examples/load.c: -------------------------------------------------------------------------------- 1 | /** @example load.c 2 | * In questo esempio si mostra come creare una lista con elementi letti da file. 3 | */ 4 | #define _CRT_SECURE_NO_WARNINGS 5 | #include "doublelist.h" 6 | 7 | #include 8 | 9 | Item *DListLoad(const char *filename) { 10 | FILE *f; 11 | f = fopen(filename, "r"); 12 | 13 | if (!f) { 14 | return NULL; 15 | } 16 | 17 | Item *i = DListCreateEmpty(); 18 | while (1) { 19 | ElemType tmp; 20 | if (1 != ElemRead(f, &tmp)) { 21 | break; 22 | } 23 | i = DListInsertHead(&tmp, i); 24 | } 25 | 26 | fclose(f); 27 | return i; 28 | } 29 | 30 | int main(void) { 31 | Item *list = DListLoad("load_example_01.txt"); 32 | 33 | DListWriteStdout(list); 34 | 35 | DListDelete(list); 36 | 37 | return EXIT_SUCCESS; 38 | } 39 | 40 | -------------------------------------------------------------------------------- /elemtype/point2d/elemtype.c: -------------------------------------------------------------------------------- 1 | #define _CRT_SECURE_NO_WARNINGS 2 | #include "elemtype.h" 3 | 4 | #include 5 | #include 6 | 7 | #define _unused(x) ((void)(x)) 8 | 9 | 10 | ElemType ElemCopy(const ElemType *e) { 11 | return *e; 12 | } 13 | 14 | void ElemSwap(ElemType *e1, ElemType *e2) { 15 | ElemType tmp = *e1; 16 | *e1 = *e2; 17 | *e2 = tmp; 18 | } 19 | 20 | void ElemDelete(ElemType *e) { 21 | // In questo caso la funzione ElemDelete non deve fare nulla, ma il 22 | // compilatore potrebbe segnalare il mancato utilizzo di e, come warning 23 | // o come errore. Utilizzando la macro _unused sopra definita eliminiamo 24 | // questo problema. 25 | _unused(e); 26 | } 27 | 28 | void ElemWrite(const ElemType *e, FILE *f) { 29 | fprintf(f, "(%d, %d)", (*e).x, (*e).y); 30 | } 31 | 32 | void ElemWriteStdout(const ElemType *e) { 33 | ElemWrite(e, stdout); 34 | } -------------------------------------------------------------------------------- /list/point2d/examples/show.c: -------------------------------------------------------------------------------- 1 | /** @example show.c 2 | * In questo esempio si mostra come creare una lista di `point 2D` a partire da 3 | * un vettore di `ElemType` e stamparla su `stdout`. Il modo in cui viene popolata 4 | * la lista è puramente esemplificativo. 5 | */ 6 | #include "list.h" 7 | 8 | #include 9 | 10 | Item *ListCreateFromVector(const int *v, size_t v_size) { 11 | Item *list = ListCreateEmpty(); 12 | for (size_t i = 0; i < v_size; i += 2) { 13 | list = ListInsertBack(list, &(ElemType){v[i], v[i + 1]}); 14 | } 15 | return list; 16 | } 17 | 18 | int main(void) { 19 | // x1 y1 x2 y2 x3 y3 x4 y4 x5 y5 20 | int v[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 21 | size_t v_size = sizeof(v) / sizeof(int); 22 | Item *list = ListCreateFromVector(v, v_size); 23 | 24 | ListWriteStdout(list); 25 | 26 | ListDelete(list); 27 | 28 | return EXIT_SUCCESS; 29 | } -------------------------------------------------------------------------------- /.github/workflows/doc.yml: -------------------------------------------------------------------------------- 1 | name: doc 2 | 3 | on: [push] 4 | 5 | jobs: 6 | docs: 7 | runs-on: ubuntu-20.04 8 | steps: 9 | - uses: actions/checkout@v2 10 | #with: 11 | # ref: master 12 | 13 | #Install dependencies 14 | - name: Dependencies 15 | run: | 16 | sudo apt update 17 | sudo apt install -y zip doxygen graphviz 18 | doxygen --version 19 | 20 | # Build the HTML documentation 21 | - name: Doxygen 22 | run: | 23 | chmod +x scripts/generate_doc.sh 24 | scripts/generate_doc.sh 25 | 26 | # Deploy the HTML documentation to GitHub Pages 27 | - name: GH Pages Deployment 28 | uses: peaceiris/actions-gh-pages@v3 29 | with: 30 | github_token: ${{ secrets.GITHUB_TOKEN }} 31 | publish_dir: ./gh-pages/ 32 | enable_jekyll: false 33 | allow_empty_commit: false 34 | force_orphan: true 35 | publish_branch: gh-pages -------------------------------------------------------------------------------- /list/int_vector/examples/show.c: -------------------------------------------------------------------------------- 1 | /** @example show.c 2 | * In questo esempio si mostra come creare una lista di `int vector` a partire da 3 | * un vettore di `ElemType` e stamparla su `stdout`. Il modo in cui viene popolata 4 | * la lista è puramente esemplificativo. 5 | */ 6 | #include "list.h" 7 | 8 | #include 9 | 10 | Item *ListCreateFromVector(const int *v, size_t v_size) { 11 | Item *list = ListCreateEmpty(); 12 | for (size_t i = 0; i < v_size; ++i) { 13 | ElemType tmp = { .size = v_size - i,.data = malloc(sizeof(int)*(v_size - i)) }; 14 | for (size_t j = i; j < v_size; ++j) { 15 | tmp.data[j - i] = v[j]; 16 | } 17 | list = ListInsertBack(list, &tmp); 18 | ElemDelete(&tmp); 19 | } 20 | return list; 21 | } 22 | 23 | int main(void) { 24 | int v[] = { 1,2,3,4,5,6,7,8,9 }; 25 | size_t v_size = sizeof(v) / sizeof(int); 26 | Item *list = ListCreateFromVector(v, v_size); 27 | 28 | ListWriteStdout(list); 29 | 30 | ListDelete(list); 31 | 32 | return EXIT_SUCCESS; 33 | } -------------------------------------------------------------------------------- /elemtype/char/elemtype.c: -------------------------------------------------------------------------------- 1 | #define _CRT_SECURE_NO_WARNINGS 2 | #include "elemtype.h" 3 | 4 | #include 5 | #include 6 | 7 | #define _unused(x) ((void)(x)) 8 | 9 | int ElemCompare(const ElemType *e1, const ElemType *e2) { 10 | return (*e1 > *e2) - (*e1 < *e2); 11 | } 12 | 13 | ElemType ElemCopy(const ElemType *e) { 14 | return *e; 15 | } 16 | 17 | void ElemSwap(ElemType *e1, ElemType *e2) { 18 | ElemType tmp = *e1; 19 | *e1 = *e2; 20 | *e2 = tmp; 21 | } 22 | 23 | void ElemDelete(ElemType *e) { 24 | // In questo caso la funzione ElemDelete non deve fare nulla, ma il 25 | // compilatore potrebbe segnalare il mancato utilizzo di e, come warning 26 | // o come errore. Utilizzando la macro _unused sopra definita eliminiamo 27 | // questo problema. 28 | _unused(e); 29 | } 30 | 31 | int ElemRead(FILE *f, ElemType *e) { 32 | return fscanf(f, "%c", e); 33 | } 34 | 35 | int ElemReadStdin(ElemType *e) { 36 | return ElemRead(stdin, e); 37 | } 38 | 39 | void ElemWrite(const ElemType *e, FILE *f) { 40 | fprintf(f, "%c", *e); 41 | } 42 | 43 | void ElemWriteStdout(const ElemType *e) { 44 | ElemWrite(e, stdout); 45 | } -------------------------------------------------------------------------------- /elemtype/int/elemtype.c: -------------------------------------------------------------------------------- 1 | #define _CRT_SECURE_NO_WARNINGS 2 | #include "elemtype.h" 3 | 4 | #include 5 | #include 6 | 7 | #define _unused(x) ((void)(x)) 8 | 9 | int ElemCompare(const ElemType *e1, const ElemType *e2) { 10 | return (*e1 > *e2) - (*e1 < *e2); 11 | } 12 | 13 | ElemType ElemCopy(const ElemType *e) { 14 | return *e; 15 | } 16 | 17 | void ElemSwap(ElemType *e1, ElemType *e2) { 18 | ElemType tmp = *e1; 19 | *e1 = *e2; 20 | *e2 = tmp; 21 | } 22 | 23 | void ElemDelete(ElemType *e) { 24 | // In questo caso la funzione ElemDelete non deve fare nulla, ma il 25 | // compilatore potrebbe segnalare il mancato utilizzo di e, come warning 26 | // o come errore. Utilizzando la macro _unused sopra definita eliminiamo 27 | // questo problema. 28 | _unused(e); 29 | } 30 | 31 | int ElemRead(FILE *f, ElemType *e) { 32 | return fscanf(f, "%d", e); 33 | } 34 | 35 | int ElemReadStdin(ElemType *e) { 36 | return ElemRead(stdin, e); 37 | } 38 | 39 | void ElemWrite(const ElemType *e, FILE *f) { 40 | fprintf(f, "%d", *e); 41 | } 42 | 43 | void ElemWriteStdout(const ElemType *e) { 44 | ElemWrite(e, stdout); 45 | } -------------------------------------------------------------------------------- /doublelist/int/examples/insert_ord.c: -------------------------------------------------------------------------------- 1 | /** @example insert_ord.c 2 | * In questo esempio si mostra come inserire un nuovo elemento in una lista esistente, 3 | * rispettando l'ordinamento crescente. 4 | */ 5 | #include "doublelist.h" 6 | 7 | #include 8 | 9 | Item *DListInsOrd(const ElemType *e, Item *i) { 10 | if (DListIsEmpty(i) || ElemCompare(DListGetHeadValue(i), e) >= 0) { 11 | return DListInsertHead(e, i); 12 | } 13 | 14 | Item *head = i; 15 | Item *new_item = DListInsertHead(e, DListCreateEmpty()); 16 | 17 | Item* prev = NULL; 18 | while (!DListIsEmpty(i) && ElemCompare(DListGetHeadValue(i), e) < 0) { 19 | prev = i; 20 | i = DListGetTail(i); 21 | } 22 | 23 | Item* next = i; 24 | new_item->next = next; 25 | new_item->prev = prev; 26 | 27 | prev->next = new_item; 28 | if (!DListIsEmpty(next)) { 29 | next->prev = new_item; 30 | } 31 | return head; 32 | } 33 | 34 | int main(void) { 35 | Item *i = DListCreateEmpty(); 36 | ElemType e; 37 | // Acquisizione di elementi da stdin 38 | do { 39 | printf("Introdurre un valore intero: "); 40 | if (ElemReadStdin(&e) != 1) { 41 | break; 42 | } 43 | i = DListInsOrd(&e, i); 44 | } while (e != 0); // L'acquisizione termina quando viene inserito lo zero. 45 | 46 | DListWriteStdout(i); 47 | DListDelete(i); 48 | return EXIT_SUCCESS; 49 | } -------------------------------------------------------------------------------- /tree/int/examples/tree_from_vector.c: -------------------------------------------------------------------------------- 1 | /** @example tree_from_vector.c 2 | * In questo esempio si mostra come creare un albero binario a partire da un 3 | * vettore di `ElemType`. 4 | */ 5 | 6 | #include 7 | 8 | #include "tree.h" 9 | 10 | // Per ogni nodo (elemento `i`-esimo del vettore) considero come figlio sinistro 11 | // l'elemento del vettore di indice `i * 2 + 1`, e come figlio destro l'elemento 12 | // di indice `i * 2 + 2`. 13 | Node *TreeCreateFromVectorRec(const int *v, size_t v_size, int i) { 14 | if (i >= (int)v_size) { 15 | return NULL; 16 | } 17 | 18 | Node *l = TreeCreateFromVectorRec(v, v_size, i * 2 + 1); 19 | Node *r = TreeCreateFromVectorRec(v, v_size, i * 2 + 2); 20 | 21 | return TreeCreateRoot(&v[i], l, r); 22 | } 23 | 24 | Node *TreeCreateFromVector(const int *v, size_t v_size) { 25 | return TreeCreateFromVectorRec(v, v_size, 0); 26 | } 27 | 28 | int main(void) { 29 | int v[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 30 | size_t v_size = sizeof(v) / sizeof(int); 31 | Node *tree = TreeCreateEmpty(); 32 | 33 | TreeWriteStdoutPreOrder(tree); 34 | TreeWriteStdoutInOrder(tree); 35 | TreeWriteStdoutPostOrder(tree); 36 | 37 | tree = TreeCreateFromVector(v, v_size); 38 | 39 | TreeWriteStdoutPreOrder(tree); 40 | TreeWriteStdoutInOrder(tree); 41 | TreeWriteStdoutPostOrder(tree); 42 | 43 | TreeDelete(tree); 44 | 45 | return EXIT_SUCCESS; 46 | } -------------------------------------------------------------------------------- /tree/int/examples/insert_ord.c: -------------------------------------------------------------------------------- 1 | /** @example insert_ord.c 2 | * In questo esempio si mostra come inserire elementi in maniera ordinata 3 | * in un albero binario. L'albero risultante sarà un BST. 4 | */ 5 | 6 | #include 7 | 8 | #include "tree.h" 9 | 10 | Node *TreeInsertBinOrd(const ElemType *e, Node* n) { 11 | if (TreeIsEmpty(n)) { 12 | return TreeCreateRoot(e, TreeCreateEmpty(), TreeCreateEmpty()); 13 | } 14 | Node *root = n; 15 | 16 | while (true) { 17 | if (ElemCompare(e, TreeGetRootValue(n)) < 0) { 18 | if (TreeIsEmpty(TreeLeft(n))) { 19 | n->left = TreeCreateRoot(e, TreeCreateEmpty(), TreeCreateEmpty()); 20 | break; 21 | } 22 | else { 23 | n = TreeLeft(n); 24 | } 25 | } 26 | else { 27 | if (TreeIsEmpty(TreeRight(n))) { 28 | n->right = TreeCreateRoot(e, TreeCreateEmpty(), TreeCreateEmpty()); 29 | break; 30 | } 31 | else { 32 | n = TreeRight(n); 33 | } 34 | } 35 | } 36 | 37 | return root; 38 | } 39 | 40 | int main(void) { 41 | int v[] = { 0, 12, 4, 21, 2, 5, 18, 77, 8, 9 }; 42 | size_t v_size = sizeof(v) / sizeof(int); 43 | 44 | Node *tree = TreeCreateEmpty(); 45 | for (unsigned i = 0; i < v_size; ++i) { 46 | tree = TreeInsertBinOrd(&v[i], tree); 47 | } 48 | 49 | TreeWriteStdoutPreOrder(tree); 50 | TreeWriteStdoutInOrder(tree); 51 | TreeWriteStdoutPostOrder(tree); 52 | TreeDelete(tree); 53 | 54 | return EXIT_SUCCESS; 55 | } -------------------------------------------------------------------------------- /list/char/examples/copy.c: -------------------------------------------------------------------------------- 1 | /** @example copy.c 2 | * In questo esempio si mostra come creare una lista a partire da un vettore di 3 | * `ElemType` e successivamente crearne una copia. 4 | */ 5 | #include "list.h" 6 | 7 | #include 8 | 9 | Item *ListCreateFromVector(const int *v, size_t v_size) { 10 | Item *list = ListCreateEmpty(); 11 | for (size_t i = 0; i < v_size; ++i) { 12 | list = ListInsertBack(list, &v[i]); 13 | } 14 | return list; 15 | } 16 | 17 | Item *ListCopy(const Item *i) { 18 | Item *list_copy = ListCreateEmpty(); // Creo una lista vuota (NULL pointer) 19 | 20 | // Itero tutti gli elementi della lista da copiare 21 | for (; !ListIsEmpty(i); i = ListGetTail(i)) { 22 | // Aggiungo l'elemento corrente della lista di input alla nuova lista 23 | // usando la primitiva ListInsertBack(), la quale si occupa di allocare 24 | // opportunamente la memoria e aggiornare i puntatori! 25 | list_copy = ListInsertBack(list_copy, ListGetHeadValue(i)); 26 | } 27 | 28 | return list_copy; 29 | } 30 | 31 | int main(void) { 32 | int v[] = { 1,2,3,4,5,6,7,8,9 }; 33 | size_t v_size = sizeof(v) / sizeof(int); 34 | Item *list = ListCreateFromVector(v, v_size); 35 | 36 | 37 | Item *list_copy = ListCopy(list); 38 | 39 | printf("Input:\n list: "); 40 | ListWriteStdout(list); 41 | printf(" head address: %p", list); 42 | printf("\n\nOutput (copy):\n list: "); 43 | ListWriteStdout(list_copy); 44 | printf(" head address: %p", list_copy); 45 | 46 | ListDelete(list); 47 | ListDelete(list_copy); 48 | 49 | return EXIT_SUCCESS; 50 | } 51 | -------------------------------------------------------------------------------- /list/int/examples/copy.c: -------------------------------------------------------------------------------- 1 | /** @example copy.c 2 | * In questo esempio si mostra come creare una lista a partire da un vettore di 3 | * `ElemType` e successivamente crearne una copia. 4 | */ 5 | #include "list.h" 6 | 7 | #include 8 | 9 | Item *ListCreateFromVector(const int *v, size_t v_size) { 10 | Item *list = ListCreateEmpty(); 11 | for (size_t i = 0; i < v_size; ++i) { 12 | list = ListInsertBack(list, &v[i]); 13 | } 14 | return list; 15 | } 16 | 17 | Item *ListCopy(const Item *i) { 18 | Item *list_copy = ListCreateEmpty(); // Creo una lista vuota (NULL pointer) 19 | 20 | // Itero tutti gli elementi della lista da copiare 21 | for (; !ListIsEmpty(i); i = ListGetTail(i)) { 22 | // Aggiungo l'elemento corrente della lista di input alla nuova lista 23 | // usando la primitiva ListInsertBack(), la quale si occupa di allocare 24 | // opportunamente la memoria e aggiornare i puntatori! 25 | list_copy = ListInsertBack(list_copy, ListGetHeadValue(i)); 26 | } 27 | 28 | return list_copy; 29 | } 30 | 31 | int main(void) { 32 | int v[] = { 1,2,3,4,5,6,7,8,9 }; 33 | size_t v_size = sizeof(v) / sizeof(int); 34 | Item *list = ListCreateFromVector(v, v_size); 35 | 36 | 37 | Item *list_copy = ListCopy(list); 38 | 39 | printf("Input:\n list: "); 40 | ListWriteStdout(list); 41 | printf(" head address: %p", list); 42 | printf("\n\nOutput (copy):\n list: "); 43 | ListWriteStdout(list_copy); 44 | printf(" head address: %p", list_copy); 45 | 46 | ListDelete(list); 47 | ListDelete(list_copy); 48 | 49 | return EXIT_SUCCESS; 50 | } 51 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | BSD 3-Clause License 2 | 3 | Copyright (c) 2020 - 2021, Federico Bolelli 4 | All rights reserved. 5 | 6 | Redistribution and use in source and binary forms, with or without 7 | modification, are permitted provided that the following conditions are met: 8 | 9 | 1. Redistributions of source code must retain the above copyright notice, this 10 | list of conditions and the following disclaimer. 11 | 12 | 2. Redistributions in binary form must reproduce the above copyright notice, 13 | this list of conditions and the following disclaimer in the documentation 14 | and/or other materials provided with the distribution. 15 | 16 | 3. Neither the name of the copyright holder nor the names of its 17 | contributors may be used to endorse or promote products derived from 18 | this software without specific prior written permission. 19 | 20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 | -------------------------------------------------------------------------------- /doublelist/int/examples/copy.c: -------------------------------------------------------------------------------- 1 | /** @example copy.c 2 | * In questo esempio si mostra come creare una lista a partire da un vettore di 3 | * `ElemType` e successivamente crearne una copia. 4 | */ 5 | #include "doublelist.h" 6 | 7 | #include 8 | 9 | Item *DListCreateFromVector(const ElemType *v, size_t v_size) { 10 | Item *list = DListCreateEmpty(); 11 | for (size_t i = 0; i < v_size; ++i) { 12 | list = DListInsertBack(list, &v[i]); 13 | } 14 | return list; 15 | } 16 | 17 | Item *DListCopy(const Item *i) { 18 | Item *list_copy = DListCreateEmpty(); // Creo una lista vuota (NULL pointer) 19 | 20 | // Itero tutti gli elementi della lista da copiare 21 | for (; !DListIsEmpty(i); i = DListGetTail(i)) { 22 | // Aggiungo l'elemento corrente della lista di input alla nuova lista 23 | // usando la primitiva ListInsertBack(), la quale si occupa di allocare 24 | // opportunamente la memoria e aggiornare i puntatori! 25 | list_copy = DListInsertBack(list_copy, DListGetHeadValue(i)); 26 | } 27 | 28 | return list_copy; 29 | } 30 | 31 | int main(void) { 32 | ElemType v[] = { 1,2,3,4,5,6,7,8,9 }; 33 | size_t v_size = sizeof(v) / sizeof(ElemType); 34 | Item *list = DListCreateFromVector(v, v_size); 35 | 36 | 37 | Item *list_copy = DListCopy(list); 38 | 39 | printf("Input:\n list: "); 40 | DListWriteStdout(list); 41 | printf(" head address: %p", list); 42 | printf("\n\nOutput (copy):\n list: "); 43 | DListWriteStdout(list_copy); 44 | printf(" head address: %p", list_copy); 45 | 46 | DListDelete(list); 47 | DListDelete(list_copy); 48 | 49 | return EXIT_SUCCESS; 50 | } 51 | -------------------------------------------------------------------------------- /maxheap/int/examples/heapify.c: -------------------------------------------------------------------------------- 1 | /** @example heapify.c 2 | * In questo esempio si mostra come convertire un vettore di `ElemType` in una 3 | * coda di priorità (max-)heap, mediante la funzione `HeapMaxMoveDown()`. Questo 4 | * procedimento prende il nome di `HeapifyMaxHeap()` 5 | */ 6 | #include 7 | #include 8 | 9 | #include "maxheap.h" 10 | 11 | /** @brief Dato un vettore di `ElemType`, la funzione `HeapifyMaxHeap()` crea una 12 | (max-)heap contenente tutti gli elementi del vettore. 13 | 14 | @param[in] v Vettore di `ElemType`. 15 | @param[in] v_size Numero di elementi contenuti in `v`. 16 | 17 | @return Puntatore alla coda (max-)heap appena creata. 18 | */ 19 | Heap *HeapifyMaxHeap(const ElemType *v, size_t v_size) { 20 | // Costruisco la heap con gli elementi del vettore v 21 | Heap *h = HeapCreateEmpty(); 22 | h->size = v_size; 23 | h->data = malloc(sizeof(ElemType)*(v_size)); 24 | memcpy(h->data, v, v_size * sizeof(ElemType)); 25 | 26 | // Chiamo la HeapMaxMoveDown a partire dai nodi nel penultimo livello 27 | // dell'albero fino alla radice, per garantire che tutti i nodi rispettino 28 | // le proprietà (max-)heap. Non serve chiamare la HeapMaxMoveDown sulle 29 | // foglie perché non avrebbe alcun effetto. 30 | for (int i = (int)h->size / 2 - 1; i >= 0; i--) { 31 | HeapMaxMoveDown(h, i); 32 | } 33 | return h; 34 | } 35 | 36 | int main(void) { 37 | ElemType v[] = { 0, 12, 4, 21, 2, 18, 77, 8, 9 }; 38 | size_t v_size = sizeof(v) / sizeof(ElemType); 39 | 40 | Heap *h = HeapifyMaxHeap(v, v_size); 41 | HeapWriteStdout(h); 42 | 43 | HeapDelete(h); 44 | 45 | return EXIT_SUCCESS; 46 | } -------------------------------------------------------------------------------- /minheap/int/examples/heapify.c: -------------------------------------------------------------------------------- 1 | /** @example heapify.c 2 | * In questo esempio si mostra come convertire un vettore di `ElemType` in una 3 | * coda di priorità (min-)heap, mediante la funzione `HeapMinMoveDown()`. Questo 4 | * procedimento prende il nome di `HeapifyMinHeap()` 5 | */ 6 | #include 7 | #include 8 | 9 | #include "minheap.h" 10 | 11 | /** @brief Dato un vettore di `ElemType`, la funzione `HeapifyMinHeap()` crea una 12 | (min-)heap contenente tutti gli elementi del vettore. 13 | 14 | @param[in] v Vettore di `ElemType`. 15 | @param[in] v_size Numero di elementi contenuti in `v`. 16 | 17 | @return Puntatore alla coda (min-)heap appena creata. 18 | */ 19 | Heap *HeapifyMinHeap(const ElemType *v, size_t v_size) { 20 | // Costruisco la heap con gli elementi del vettore v 21 | Heap *h = HeapCreateEmpty(); 22 | h->size = v_size; 23 | h->data = malloc(sizeof(ElemType)*(v_size)); 24 | memcpy(h->data, v, v_size * sizeof(ElemType)); 25 | 26 | // Chiamo la HeapMinMoveDown a partire dai nodi nel penultimo livello 27 | // dell'albero fino alla radice, per garantire che tutti i nodi rispettino 28 | // le proprietà (min-)heap. Non serve chiamare la HeapMinMoveDown sulle 29 | // foglie perché non avrebbe alcun effetto. 30 | for (int i = (int)h->size / 2 - 1; i >= 0; i--) { 31 | HeapMinMoveDown(h, i); 32 | } 33 | return h; 34 | } 35 | 36 | int main(void) { 37 | ElemType v[] = { 0, 12, 4, 21, 2, 18, 77, 8, 9 }; 38 | size_t v_size = sizeof(v) / sizeof(ElemType); 39 | 40 | Heap *h = HeapifyMinHeap(v, v_size); 41 | HeapWriteStdout(h); 42 | 43 | HeapDelete(h); 44 | 45 | return EXIT_SUCCESS; 46 | } -------------------------------------------------------------------------------- /elemtype/int_vector/elemtype.c: -------------------------------------------------------------------------------- 1 | #define _CRT_SECURE_NO_WARNINGS 2 | #include "list.h" 3 | 4 | #include 5 | #include 6 | 7 | int ElemCompare(const ElemType *e1, const ElemType *e2) { 8 | for (size_t i = 0; i < e1->size && i < e2->size; ++i) { 9 | if (e1->data[i] != e2->data[i]) { 10 | return (e1->data[i] > e2->data[i]) - (e1->data[i] < e2->data[i]); 11 | } 12 | } 13 | 14 | return (int)(e1->size - e2->size); 15 | } 16 | 17 | ElemType ElemCopy(const ElemType *e) { 18 | ElemType copy = { .size = e->size,.data = malloc(sizeof(int) * e->size) }; 19 | memcpy(copy.data, e->data, sizeof(int)*e->size); 20 | return copy; 21 | } 22 | 23 | void ElemSwap(ElemType *e1, ElemType *e2) { 24 | ElemType tmp = *e1; 25 | *e1 = *e2; 26 | *e2 = tmp; 27 | } 28 | 29 | void ElemDelete(ElemType *e) { 30 | free(e->data); 31 | } 32 | 33 | int ElemRead(FILE *f, ElemType *e) { 34 | int ret = fscanf(f, "%zu", &e->size); 35 | e->data = NULL; 36 | if (ret == 1){ 37 | e->data = malloc(sizeof(int)*e->size); 38 | for (size_t i = 0; i < e->size; ++i) { 39 | if (!fscanf(f, "%i", &e->data[i])) { 40 | return 0; 41 | } 42 | } 43 | } 44 | return ret; 45 | } 46 | 47 | int ElemReadStdin(ElemType *e) { 48 | return ElemRead(stdin, e); 49 | } 50 | 51 | void ElemWrite(const ElemType *e, FILE *f) { 52 | fprintf(f, "["); 53 | for (size_t i = 0; i < e->size; ++i) { 54 | fprintf(f, "%i", e->data[i]); 55 | if (i != e->size - 1) { 56 | printf(", "); 57 | } 58 | } 59 | fprintf(f, "]"); 60 | } 61 | 62 | void ElemWriteStdout(const ElemType *e) { 63 | ElemWrite(e, stdout); 64 | } 65 | -------------------------------------------------------------------------------- /list/int/examples/insert_ord.c: -------------------------------------------------------------------------------- 1 | /** @example insert_ord.c 2 | * In questo esempio si mostra come inserire un nuovo elemento in una lista esistente, 3 | * rispettando l'ordinamento crescente. 4 | */ 5 | #include "list.h" 6 | 7 | #include 8 | 9 | Item *ListInsOrdRec(const ElemType *e, Item *i) { 10 | if (ListIsEmpty(i) || ElemCompare(ListGetHeadValue(i), e) >= 0) { 11 | return ListInsertHead(e, i); 12 | } 13 | Item *tmp = ListInsertHead(ListGetHeadValue(i), ListInsOrdRec(e, ListGetTail(i))); 14 | free(i); 15 | return tmp; 16 | } 17 | 18 | Item *ListInsOrd(const ElemType *e, Item *i) { 19 | if (ListIsEmpty(i) || ElemCompare(ListGetHeadValue(i), e) >= 0) { 20 | return ListInsertHead(e, i); 21 | } 22 | 23 | Item *root = i; 24 | Item *prev = ListCreateEmpty(); 25 | Item *new_item = ListInsertHead(e, ListCreateEmpty()); 26 | 27 | while (!ListIsEmpty(i) && ElemCompare(ListGetHeadValue(i), e) < 0) { 28 | prev = i; 29 | i = ListGetTail(i); 30 | } 31 | prev->next = new_item; 32 | new_item->next = i; 33 | return root; 34 | } 35 | 36 | int main(void) { 37 | Item *i = ListCreateEmpty(); 38 | Item *i_rec = ListCreateEmpty(); 39 | ElemType e; 40 | // Acquisizione di elementi da stdin 41 | do { 42 | printf("Introdurre un valore intero: "); 43 | if (ElemReadStdin(&e) != 1) { 44 | break; 45 | } 46 | i = ListInsOrd(&e, i); 47 | i_rec = ListInsOrdRec(&e, i_rec); 48 | } while (e != 0); // L'acquisizione termina quando viene inserito lo zero. 49 | 50 | ListWriteStdout(i); 51 | ListWriteStdout(i_rec); 52 | 53 | ListDelete(i); 54 | ListDelete(i_rec); 55 | 56 | return EXIT_SUCCESS; 57 | } -------------------------------------------------------------------------------- /list/char/examples/insert_ord.c: -------------------------------------------------------------------------------- 1 | /** @example insert_ord.c 2 | * In questo esempio si mostra come inserire un nuovo elemento in una lista esistente, 3 | * rispettando l'ordinamento crescente. 4 | */ 5 | #include "list.h" 6 | 7 | #include 8 | 9 | Item *ListInsOrdRec(const ElemType *e, Item *i) { 10 | if (ListIsEmpty(i) || ElemCompare(ListGetHeadValue(i), e) >= 0) { 11 | return ListInsertHead(e, i); 12 | } 13 | Item *tmp = ListInsertHead(ListGetHeadValue(i), ListInsOrdRec(e, ListGetTail(i))); 14 | free(i); 15 | return tmp; 16 | } 17 | 18 | Item *ListInsOrd(const ElemType *e, Item *i) { 19 | if (ListIsEmpty(i) || ElemCompare(ListGetHeadValue(i), e) >= 0) { 20 | return ListInsertHead(e, i); 21 | } 22 | 23 | Item *root = i; 24 | Item *prev = ListCreateEmpty(); 25 | Item *new_item = ListInsertHead(e, ListCreateEmpty()); 26 | 27 | while (!ListIsEmpty(i) && ElemCompare(ListGetHeadValue(i), e) < 0) { 28 | prev = i; 29 | i = ListGetTail(i); 30 | } 31 | prev->next = new_item; 32 | new_item->next = i; 33 | return root; 34 | } 35 | 36 | int main(void) { 37 | Item *i = ListCreateEmpty(); 38 | Item *i_rec = ListCreateEmpty(); 39 | ElemType e; 40 | // Acquisizione di elementi da stdin 41 | do { 42 | printf("Introdurre un valore intero: "); 43 | if (ElemReadStdin(&e) != 1) { 44 | break; 45 | } 46 | i = ListInsOrd(&e, i); 47 | i_rec = ListInsOrdRec(&e, i_rec); 48 | } while (e != 0); // L'acquisizione termina quando viene inserito lo zero. 49 | 50 | ListWriteStdout(i); 51 | ListWriteStdout(i_rec); 52 | 53 | ListDelete(i); 54 | ListDelete(i_rec); 55 | 56 | return EXIT_SUCCESS; 57 | } -------------------------------------------------------------------------------- /list/char/examples/iterate.c: -------------------------------------------------------------------------------- 1 | /** @example iterate.c 2 | * In questo esempio si mostra come creare una lista a partire da un vettore di 3 | * `ElemType` e come iterare gli elementi di una lista esistente utilizzando i 4 | * ciclo `for` e `while` facendo o meno uso delle funzioni primitive. 5 | */ 6 | #include "list.h" 7 | 8 | #include 9 | 10 | Item *ListCreateFromVector(const int *v, size_t v_size) { 11 | Item *list = ListCreateEmpty(); 12 | for (size_t i = 0; i < v_size; ++i) { 13 | list = ListInsertBack(list, &v[i]); 14 | } 15 | return list; 16 | } 17 | 18 | int main(void) { 19 | int v[] = { 1,2,3,4,5,6,7,8,9 }; 20 | size_t v_size = sizeof(v) / sizeof(int); 21 | Item *list = ListCreateFromVector(v, v_size); 22 | 23 | // Iterazione con il for usando le primitive: 24 | for (Item *tmp = list; !ListIsEmpty(tmp); tmp = ListGetTail(tmp)) { 25 | // Prendo il valore dell'elemento corrente della lista. 26 | const ElemType *e = ListGetHeadValue(tmp); 27 | // Se volessi un elemento modificabile potrei fare: 28 | // ElemType e = ElemCopy(ListGetHeadValue(tmp)); 29 | 30 | // E lo uso 31 | // ... 32 | } 33 | 34 | // Iterazione con il for senza la primitive: 35 | for (Item *tmp = list; tmp; tmp = tmp->next) { 36 | ElemType e = tmp->value; 37 | // Cose ... 38 | } 39 | 40 | // Iterazione con il while usando le primitive: 41 | Item *tmp = list; 42 | while (!ListIsEmpty(tmp)) { 43 | const ElemType *e = ListGetHeadValue(tmp); 44 | // Cose ... 45 | 46 | tmp = ListGetTail(tmp); 47 | } 48 | 49 | // Iterazione con il while senza le primitive: 50 | /*Item**/ tmp = list; 51 | while (tmp) { 52 | ElemType e = tmp->value; 53 | // Cose ... 54 | tmp = tmp->next; 55 | } 56 | 57 | ListDelete(list); 58 | 59 | return EXIT_SUCCESS; 60 | } -------------------------------------------------------------------------------- /list/int/examples/iterate.c: -------------------------------------------------------------------------------- 1 | /** @example iterate.c 2 | * In questo esempio si mostra come creare una lista a partire da un vettore di 3 | * `ElemType` e come iterare gli elementi di una lista esistente utilizzando i 4 | * ciclo `for` e `while` facendo o meno uso delle funzioni primitive. 5 | */ 6 | #include "list.h" 7 | 8 | #include 9 | 10 | Item *ListCreateFromVector(const int *v, size_t v_size) { 11 | Item *list = ListCreateEmpty(); 12 | for (size_t i = 0; i < v_size; ++i) { 13 | list = ListInsertBack(list, &v[i]); 14 | } 15 | return list; 16 | } 17 | 18 | int main(void) { 19 | int v[] = { 1,2,3,4,5,6,7,8,9 }; 20 | size_t v_size = sizeof(v) / sizeof(int); 21 | Item *list = ListCreateFromVector(v, v_size); 22 | 23 | // Iterazione con il for usando le primitive: 24 | for (Item *tmp = list; !ListIsEmpty(tmp); tmp = ListGetTail(tmp)) { 25 | // Prendo il valore dell'elemento corrente della lista. 26 | const ElemType *e = ListGetHeadValue(tmp); 27 | // Se volessi un elemento modificabile potrei fare: 28 | // ElemType e = ElemCopy(ListGetHeadValue(tmp)); 29 | 30 | // E lo uso 31 | // ... 32 | } 33 | 34 | // Iterazione con il for senza la primitive: 35 | for (Item *tmp = list; tmp; tmp = tmp->next) { 36 | ElemType e = tmp->value; 37 | // Cose ... 38 | } 39 | 40 | // Iterazione con il while usando le primitive: 41 | Item *tmp = list; 42 | while (!ListIsEmpty(tmp)) { 43 | const ElemType *e = ListGetHeadValue(tmp); 44 | // Cose ... 45 | 46 | tmp = ListGetTail(tmp); 47 | } 48 | 49 | // Iterazione con il while senza le primitive: 50 | /*Item**/ tmp = list; 51 | while (tmp) { 52 | ElemType e = tmp->value; 53 | // Cose ... 54 | tmp = tmp->next; 55 | } 56 | 57 | ListDelete(list); 58 | 59 | return EXIT_SUCCESS; 60 | } -------------------------------------------------------------------------------- /minheap/int/examples/heapsort.c: -------------------------------------------------------------------------------- 1 | /** @example heapsort.c 2 | * In questo esempio si mostra come ordinare in senso decrescente i dati contenuti 3 | * in una coda di priorità, sfruttando le proprietà (min-)heap. 4 | */ 5 | #include 6 | #include 7 | 8 | #include "minheap.h" 9 | 10 | /** @brief Data una coda di priorità, la funzione `Heapsort()` ordina il vettore 11 | dei dati sfruttando le proprietà (min-)heap. Si noti che al termine 12 | dell'operazione il vettore dei dati sarà ordinato (in senso decrescente), 13 | ma NON rispetterà più le proprietà (min-)heap. 14 | 15 | 16 | @param[in] h Heap da ordinare. 17 | 18 | @return Non ci sono valori di ritorno. 19 | */ 20 | void HeapsortMinHeap(Heap *h) { 21 | size_t origin_size = h->size; // Ci salviamo la dimensione originaria per 22 | // ripristinarla al termine. 23 | 24 | while(h->size >= 2) { 25 | ElemSwap(HeapGetNodeValue(h, 0), HeapGetNodeValue(h, h->size - 1)); 26 | h->size--; 27 | HeapMinMoveDown(h, 0); 28 | } 29 | h->size = origin_size; // Ripristiniamo la dimensione originaria altrimenti 30 | // il distruttore della heap (HeapDelete) non può 31 | // fare il suo dovere. 32 | } 33 | 34 | Heap* HeapifyMinHeap(ElemType *v, size_t v_size) { 35 | Heap *h = HeapCreateEmpty(); 36 | h->size = v_size; 37 | h->data = malloc(sizeof(ElemType)*(v_size)); 38 | memcpy(h->data, v, v_size * sizeof(ElemType)); 39 | 40 | for (int i = (int)h->size / 2 - 1; i >= 0; i--) { 41 | HeapMinMoveDown(h, i); 42 | } 43 | return h; 44 | } 45 | 46 | int main(void) { 47 | ElemType v[] = { 0, 12, 4, 21, 2, 5, 18, 77, 8, 9 }; 48 | size_t v_size = sizeof(v) / sizeof(ElemType); 49 | 50 | Heap* h = HeapifyMinHeap(v, v_size); 51 | HeapWriteStdout(h); 52 | 53 | HeapsortMinHeap(h); 54 | HeapWriteStdout(h); 55 | 56 | HeapDelete(h); 57 | 58 | return EXIT_SUCCESS; 59 | } -------------------------------------------------------------------------------- /maxheap/int/examples/heapsort.c: -------------------------------------------------------------------------------- 1 | /** @example heapsort.c 2 | * In questo esempio si mostra come ordinare in senso decrescente i dati contenuti 3 | * in una coda di priorità, sfruttando le proprietà (max-)heap. 4 | */ 5 | #include 6 | #include 7 | 8 | #include "maxheap.h" 9 | 10 | /** @brief Data una coda di priorità, la funzione `Heapsort()` ordina il vettore 11 | dei dati sfruttando le proprietà (max-)heap. Si noti che al termine 12 | dell'operazione il vettore dei dati sarà ordinato (in senso decrescente), 13 | ma NON rispetterà più le proprietà (max-)heap. 14 | 15 | 16 | @param[in] h Heap da ordinare. 17 | 18 | @return Non ci sono valori di ritorno. 19 | */ 20 | void HeapsortMaxHeap(Heap *h) { 21 | size_t origin_size = h->size; // Ci salviamo la dimensione originaria per 22 | // ripristinarla al termine. 23 | 24 | while(h->size >= 2) { 25 | ElemSwap(HeapGetNodeValue(h, 0), HeapGetNodeValue(h, (int)h->size - 1)); 26 | h->size--; 27 | HeapMaxMoveDown(h, 0); 28 | } 29 | h->size = origin_size; // Ripristiniamo la dimensione originaria altrimenti 30 | // il distruttore della heap (HeapDelete) non può 31 | // fare il suo dovere. 32 | } 33 | 34 | Heap* HeapifyMaxHeap(ElemType *v, size_t v_size) { 35 | Heap *h = HeapCreateEmpty(); 36 | h->size = v_size; 37 | h->data = malloc(sizeof(ElemType)*(v_size)); 38 | memcpy(h->data, v, v_size * sizeof(ElemType)); 39 | 40 | for (int i = (int)h->size / 2 - 1; i >= 0; i--) { 41 | HeapMaxMoveDown(h, i); 42 | } 43 | return h; 44 | } 45 | 46 | int main(void) { 47 | ElemType v[] = { 0, 12, 4, 21, 2, 5, 18, 77, 8, 9 }; 48 | size_t v_size = sizeof(v) / sizeof(ElemType); 49 | 50 | Heap* h = HeapifyMaxHeap(v, v_size); 51 | HeapWriteStdout(h); 52 | 53 | HeapsortMaxHeap(h); 54 | HeapWriteStdout(h); 55 | 56 | HeapDelete(h); 57 | 58 | return EXIT_SUCCESS; 59 | } -------------------------------------------------------------------------------- /elemtype/point2d/elemtype.h: -------------------------------------------------------------------------------- 1 | /** @file 2 | Questo file contiene la definizione di `ElemType` per il tipo `Point 2D` e la 3 | documentazione delle funzioni a esso associate. 4 | */ 5 | 6 | #ifndef ELEMTYPE_PUNTO_H_ 7 | #define ELEMTYPE_PUNTO_H_ 8 | 9 | #include 10 | #include 11 | 12 | /** @brief Definizione di `struct ElemType`. */ 13 | typedef struct { 14 | int x; 15 | int y; 16 | } Point2D; 17 | 18 | typedef Point2D ElemType; 19 | 20 | /** @brief La funzione `ElemCopy()` crea e ritorna una copia dell'elemento dato. 21 | 22 | @param[in] e Puntatore all'elemento da copiare. Il valore contenuto in `e` non 23 | viene modificato. 24 | 25 | @return Copia dell'elemento `e`. 26 | */ 27 | ElemType ElemCopy(const ElemType *e); 28 | 29 | /** @brief La funzione `ElemSwap()` scambia i due elementi specificati. 30 | 31 | @param[in] e1 Puntatore al primo elemento da scambiare. 32 | @param[in] e2 Puntatore al secondo elemento da scambiare. 33 | 34 | @return Non ci sono valori di ritorno. 35 | */ 36 | void ElemSwap(ElemType *e1, ElemType *e2); 37 | 38 | /** @brief La funzione `ElemDelete()` libera la memoria occupata dall'elemento 39 | specificato. 40 | 41 | @param[in] e Puntatore all'elemento di cui liberare la memoria. 42 | 43 | @return Non ci sono valori di ritorno. 44 | */ 45 | void ElemDelete(ElemType *e); 46 | 47 | /** @brief La funzione `ElemWrite()` stampa un elemento su file. 48 | 49 | @param[in] e Puntatore all'elemento da stampare su file. Il valore contenuto in 50 | e non viene modificato. 51 | @param[in] f `FILE *` su cui stampare l'elemento. 52 | 53 | @return Non ci sono valori di ritorno. 54 | */ 55 | void ElemWrite(const ElemType *e, FILE *f); 56 | 57 | /** @brief La funzione `ElemWriteStdout()` stampa un elemento su `stdout`. 58 | 59 | @param[in] e Puntatore all'elemento da stampare su `stdout`. Il valore 60 | contenuto in `e` non viene modificato. 61 | 62 | @return Non ci sono valori di ritorno. 63 | */ 64 | void ElemWriteStdout(const ElemType *e); 65 | 66 | #endif // ELEMTYPE_INT_H_ 67 | 68 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.0.0) 2 | 3 | project ("fondamenti-ii") 4 | 5 | set_property(GLOBAL PROPERTY USE_FOLDERS ON) 6 | 7 | set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Configs" FORCE) 8 | set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}" CACHE PATH "Install prefix" FORCE) 9 | 10 | if(MSVC) 11 | set(CMAKE_USE_RELATIVE_PATHS ON CACHE INTERNAL "" FORCE) 12 | endif() 13 | 14 | if(DEFINED CMAKE_BUILD_TYPE) 15 | set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${CMAKE_CONFIGURATION_TYPES}) 16 | endif() 17 | 18 | set(SUB_DIRS "doublelist" "list" "tree" "minheap" "maxheap") 19 | # message(STATUS ${SUB_DIRS}) 20 | 21 | FOREACH(cur_dir ${SUB_DIRS}) 22 | # message(STATUS "cur_dir: ${cur_dir}") 23 | file(GLOB sub_sub_dirs "${cur_dir}/*") 24 | FOREACH(cur_sub_dir ${sub_sub_dirs}) 25 | 26 | get_filename_component(dir_name "${cur_sub_dir}" NAME) 27 | # message(STATUS "dir_name: ${dir_name}") 28 | if(IS_DIRECTORY ${cur_sub_dir} AND NOT ${dir_name} STREQUAL "doxygen") 29 | # message(STATUS "cur_sub_dir: ${cur_sub_dir}") 30 | 31 | # get_filename_component(dir_name "${cur_sub_dir}" NAME) 32 | set(target_name "${cur_dir}_${dir_name}") 33 | string(TOUPPER ${target_name} target_name_uppercase) 34 | 35 | # file(GLOB sources ${cur_sub_dir}/*.c) 36 | # file(GLOB headers ${cur_sub_dir}/*.h) 37 | 38 | # add_library(${target_name_uppercase} STATIC ${sources} ${headers}) 39 | add_library(${target_name_uppercase}) 40 | 41 | target_sources(${target_name_uppercase} 42 | PRIVATE 43 | ${cur_sub_dir}/../${cur_dir}.h 44 | ${cur_sub_dir}/../${cur_dir}.c 45 | elemtype/${dir_name}/elemtype.h 46 | elemtype/${dir_name}/elemtype.c 47 | ) 48 | 49 | target_include_directories(${target_name_uppercase} PUBLIC ${cur_sub_dir}/../) 50 | target_include_directories(${target_name_uppercase} PUBLIC ${cur_sub_dir}/../../elemtype/${dir_name}/) 51 | 52 | set(cur_folder "${cur_dir}/${dir_name}") 53 | set_target_properties(${target_name_uppercase} PROPERTIES FOLDER ${cur_folder}) # Set target folder 54 | 55 | # Add examples 56 | if(EXISTS ${cur_sub_dir}/examples) 57 | add_subdirectory(${cur_sub_dir}/examples) 58 | endif() 59 | endif() 60 | ENDFOREACH() 61 | ENDFOREACH() -------------------------------------------------------------------------------- /list/list.c: -------------------------------------------------------------------------------- 1 | #define _CRT_SECURE_NO_WARNINGS 2 | #include "list.h" 3 | 4 | #include 5 | #include 6 | 7 | /*****************************************************************************/ 8 | /* Item & Primitives */ 9 | /*****************************************************************************/ 10 | 11 | Item *ListCreateEmpty(void) { 12 | return NULL; 13 | } 14 | 15 | Item *ListInsertHead(const ElemType *e, Item *i) { 16 | Item *n = malloc(sizeof(Item)); 17 | n->value = ElemCopy(e); 18 | n->next = i; 19 | return n; 20 | } 21 | 22 | bool ListIsEmpty(const Item *i) { 23 | return i == NULL; 24 | } 25 | 26 | const ElemType *ListGetHeadValue(const Item *i) { 27 | if (ListIsEmpty(i)) { 28 | printf("ERROR: Alla funzione 'ListGetHead()' e' stata passata una lista vuota (NULL).\n"); 29 | exit(1); 30 | } 31 | else { 32 | return &i->value; 33 | } 34 | } 35 | 36 | Item *ListGetTail(const Item *i) { 37 | if (ListIsEmpty(i)) { 38 | printf("ERROR: Alla funzione 'ListGetTail()' e' stata passata una lista vuota (NULL).\n"); 39 | exit(2); 40 | } 41 | else { 42 | return i->next; 43 | } 44 | } 45 | 46 | Item *ListInsertBack(Item *i, const ElemType *e) { 47 | 48 | Item *n = ListInsertHead(e, ListCreateEmpty()); 49 | 50 | if (ListIsEmpty(i)) { 51 | return n; 52 | } 53 | 54 | Item *tmp = i; 55 | while (!ListIsEmpty(ListGetTail(tmp))) { 56 | tmp = ListGetTail(tmp); 57 | } 58 | 59 | tmp->next = n; 60 | return i; 61 | } 62 | 63 | void ListDelete(Item *i) { 64 | while (!ListIsEmpty(i)) { 65 | Item *tmp = i; 66 | i = i->next; 67 | ElemDelete(&tmp->value); 68 | free(tmp); 69 | } 70 | } 71 | 72 | /*****************************************************************************/ 73 | /* Non Primitives */ 74 | /*****************************************************************************/ 75 | 76 | void ListWrite(const Item *i, FILE *f) { 77 | fprintf(f, "["); 78 | while (!ListIsEmpty(i)) { 79 | ElemWrite(&i->value, f); 80 | i = ListGetTail(i); 81 | if (!ListIsEmpty(i)) { 82 | fprintf(f, ", "); 83 | } 84 | } 85 | fprintf(f, "]\n"); 86 | } 87 | 88 | void ListWriteStdout(const Item *i) { 89 | ListWrite(i, stdout); 90 | } -------------------------------------------------------------------------------- /doc/utils/header.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | $projectname: $title 9 | $title 10 | 11 | 12 | 13 | 14 | 15 | 16 | 41 | 42 | 43 | 44 | 45 | 46 |
47 |
48 | 49 | 50 | 51 | 52 | 56 | 57 | 58 |
53 |
54 |
55 |
59 |
-------------------------------------------------------------------------------- /doublelist/int/examples/iterate.c: -------------------------------------------------------------------------------- 1 | /** @example iterate.c 2 | * In questo esempio si mostra come creare una lista a partire da un vettore di 3 | * `ElemType` e come iterare gli elementi di una lista esistente utilizzando i 4 | * ciclo `for` e `while` facendo o meno uso delle funzioni primitive. 5 | */ 6 | #include "doublelist.h" 7 | 8 | #include 9 | 10 | Item *DListCreateFromVector(const ElemType *v, size_t v_size) { 11 | Item *list = DListCreateEmpty(); 12 | for (size_t i = 0; i < v_size; ++i) { 13 | list = DListInsertBack(list, &v[i]); 14 | } 15 | return list; 16 | } 17 | 18 | int main(void) { 19 | ElemType v[] = { 1,2,3,4,5,6,7,8,9 }; 20 | size_t v_size = sizeof(v) / sizeof(ElemType); 21 | Item *list = DListCreateFromVector(v, v_size); 22 | 23 | // Iterazione con il for usando le primitive: 24 | for (Item *tmp = list; !DListIsEmpty(tmp); tmp = DListGetTail(tmp)) { 25 | // Prendo il valore dell'elemento corrente della lista. 26 | const ElemType *e = DListGetHeadValue(tmp); 27 | // Se volessi un elemento modificabile potrei fare: 28 | // ElemType e = ElemCopy(DListGetHeadValue(tmp)); 29 | 30 | // E lo uso 31 | // ... 32 | } 33 | 34 | // Iterazione con il for senza la primitive: 35 | for (Item *tmp = list; tmp; tmp = tmp->next) { 36 | ElemType e = tmp->value; 37 | // Cose ... 38 | } 39 | 40 | // Iterazione con il while usando le primitive: 41 | Item *tmp = list; 42 | while (!DListIsEmpty(tmp)) { 43 | const ElemType *e = DListGetHeadValue(tmp); 44 | // Cose ... 45 | 46 | tmp = DListGetTail(tmp); 47 | } 48 | 49 | // Iterazione con il while senza le primitive: 50 | /*Item**/ tmp = list; 51 | while (tmp) { 52 | ElemType e = tmp->value; 53 | // Cose ... 54 | tmp = tmp->next; 55 | } 56 | 57 | // Esempio di uso del puntatote al precedente. Itero fino all'ultimo elemento non NULL 58 | // e poi torno indietro fino al primo non NULL (la testa della lista). Implementazione 59 | // che fa uso delle primitive. 60 | /*Item**/ tmp = list; 61 | while (!DListIsEmpty(DListGetTail(tmp))) { 62 | const ElemType e = DListGetHeadValue(tmp); 63 | // Cose ... 64 | tmp = DListGetTail(tmp); 65 | } 66 | while (!DListIsEmpty(DListGetPrev(tmp))) { 67 | const ElemType e = DListGetHeadValue(tmp); 68 | // Cose ... 69 | tmp = DListGetPrev(tmp); 70 | } 71 | 72 | // Esempio di uso del puntatote al precedente. Itero fino all'ultimo elemento non NULL 73 | // e poi torno indietro fino al primo non NULL (la testa della lista). Implementazione 74 | // senza primitive. 75 | /*Item**/ tmp = list; 76 | while (tmp->next) { 77 | ElemType e = tmp->value; 78 | // Cose ... 79 | tmp = tmp->next; 80 | } 81 | while (tmp->prev) { 82 | ElemType e = tmp->value; 83 | // Cose ... 84 | tmp = tmp->prev; 85 | } 86 | 87 | DListDelete(list); 88 | 89 | return EXIT_SUCCESS; 90 | } -------------------------------------------------------------------------------- /maxheap/maxheap.c: -------------------------------------------------------------------------------- 1 | #define _CRT_SECURE_NO_WARNINGS 2 | #include "maxheap.h" 3 | 4 | #include 5 | #include 6 | 7 | /*****************************************************************************/ 8 | /* Node & Primitives */ 9 | /*****************************************************************************/ 10 | 11 | int HeapLeft(int i) { 12 | return 2 * i + 1; 13 | } 14 | 15 | int HeapRight(int i) { 16 | return 2 * i + 2; 17 | } 18 | 19 | int HeapParent(int i) { 20 | return (i - 1) / 2; 21 | } 22 | 23 | bool HeapIsEmpty(const Heap *h) { 24 | return h->size == 0; 25 | } 26 | 27 | Heap *HeapCreateEmpty() { 28 | Heap *h = malloc(1 * sizeof(Heap)); 29 | h->size = 0; 30 | h->data = NULL; 31 | return h; 32 | } 33 | 34 | void HeapMaxInsertNode(Heap *h, const ElemType *e) { 35 | h->size++; 36 | h->data = realloc(h->data, sizeof(ElemType)*h->size); 37 | 38 | h->data[h->size - 1] = ElemCopy(e); 39 | 40 | HeapMaxMoveUp(h, (int)h->size - 1); 41 | } 42 | 43 | ElemType *HeapGetNodeValue(const Heap *h, int i) { 44 | if (!h || i >= (int)h->size) { 45 | printf("ERROR: 'HeapGetNodeValue()' si sta provando ad accedere ad un nodo che non fa parte dello heap.\n"); 46 | exit(1); 47 | } 48 | else { 49 | return &h->data[i]; 50 | } 51 | } 52 | 53 | void HeapMaxMoveUp(Heap *h, int i) { 54 | while (i != 0 && ElemCompare(HeapGetNodeValue(h, i), HeapGetNodeValue(h, HeapParent(i))) > 0) { 55 | ElemSwap(HeapGetNodeValue(h, i), HeapGetNodeValue(h, HeapParent(i))); 56 | i = HeapParent(i); 57 | } 58 | } 59 | 60 | void HeapMaxMoveDown(Heap *h, int i) { 61 | int l, r, smallest = i; 62 | bool done; 63 | do { 64 | done = true; 65 | l = HeapLeft(i); 66 | r = HeapRight(i); 67 | 68 | if ((l < (int)h->size) && ElemCompare(HeapGetNodeValue(h, l), HeapGetNodeValue(h, smallest)) > 0) { 69 | smallest = l; 70 | } 71 | 72 | if ((r < (int)h->size) && ElemCompare(HeapGetNodeValue(h, r), HeapGetNodeValue(h, smallest)) > 0) { 73 | smallest = r; 74 | } 75 | 76 | if (smallest != i) { 77 | ElemSwap(HeapGetNodeValue(h, i), HeapGetNodeValue(h, smallest)); 78 | i = smallest; 79 | done = false; 80 | } 81 | 82 | } while (!done); 83 | } 84 | 85 | void HeapDelete(Heap *h) { 86 | for (size_t i = 0; i < h->size; ++i) { 87 | ElemDelete(&h->data[i]); 88 | } 89 | free(h->data); 90 | free(h); 91 | } 92 | 93 | /*****************************************************************************/ 94 | /* Non Primitives */ 95 | /*****************************************************************************/ 96 | 97 | void HeapWrite(const Heap *h, FILE *f) { 98 | fprintf(f, "["); 99 | for (int i = 0; i < h->size; ++i) { 100 | ElemWrite(HeapGetNodeValue(h, i), f); 101 | if (i != h->size - 1) { 102 | fprintf(f, ", "); 103 | } 104 | } 105 | fprintf(f, "]\n"); 106 | } 107 | 108 | void HeapWriteStdout(const Heap *h) { 109 | HeapWrite(h, stdout); 110 | } -------------------------------------------------------------------------------- /minheap/minheap.c: -------------------------------------------------------------------------------- 1 | #define _CRT_SECURE_NO_WARNINGS 2 | #include "minheap.h" 3 | 4 | #include 5 | #include 6 | 7 | /*****************************************************************************/ 8 | /* Node & Primitives */ 9 | /*****************************************************************************/ 10 | 11 | int HeapLeft(int i) { 12 | return 2 * i + 1; 13 | } 14 | 15 | int HeapRight(int i) { 16 | return 2 * i + 2; 17 | } 18 | 19 | int HeapParent(int i) { 20 | return (i - 1) / 2; 21 | } 22 | 23 | bool HeapIsEmpty(const Heap *h) { 24 | return h->size == 0; 25 | } 26 | 27 | Heap *HeapCreateEmpty() { 28 | Heap *h = malloc(1 * sizeof(Heap)); 29 | h->size = 0; 30 | h->data = NULL; 31 | return h; 32 | } 33 | 34 | void HeapMinInsertNode(Heap *h, const ElemType *e) { 35 | h->size++; 36 | h->data = realloc(h->data, sizeof(ElemType)*h->size); 37 | 38 | h->data[h->size - 1] = ElemCopy(e); 39 | 40 | HeapMinMoveUp(h, (int)h->size - 1); 41 | } 42 | 43 | ElemType *HeapGetNodeValue(const Heap *h, int i) { 44 | if (!h || i >= (int)h->size) { 45 | printf("ERROR: 'HeapGetNodeValue()' si sta provando ad accedere ad un nodo che non fa parte dello heap.\n"); 46 | exit(1); 47 | } 48 | else { 49 | return &h->data[i]; 50 | } 51 | } 52 | 53 | void HeapMinMoveUp(Heap *h, int i) { 54 | while (i != 0 && ElemCompare(HeapGetNodeValue(h, i), HeapGetNodeValue(h, HeapParent(i))) < 0) { 55 | ElemSwap(HeapGetNodeValue(h, i), HeapGetNodeValue(h, HeapParent(i))); 56 | i = HeapParent(i); 57 | } 58 | } 59 | 60 | void HeapMinMoveDown(Heap *h, int i) { 61 | int l, r, smallest = i; 62 | bool done; 63 | do { 64 | done = true; 65 | l = HeapLeft(i); 66 | r = HeapRight(i); 67 | 68 | if ((l < (int)h->size) && ElemCompare(HeapGetNodeValue(h, l), HeapGetNodeValue(h, smallest)) < 0) { 69 | smallest = l; 70 | } 71 | 72 | if ((r < (int)h->size) && ElemCompare(HeapGetNodeValue(h, r), HeapGetNodeValue(h, smallest)) < 0) { 73 | smallest = r; 74 | } 75 | 76 | if (smallest != i) { 77 | ElemSwap(HeapGetNodeValue(h, i), HeapGetNodeValue(h, smallest)); 78 | i = smallest; 79 | done = false; 80 | } 81 | 82 | } while (!done); 83 | } 84 | 85 | void HeapDelete(Heap *h) { 86 | for (size_t i = 0; i < h->size; ++i) { 87 | ElemDelete(&h->data[i]); 88 | } 89 | free(h->data); 90 | free(h); 91 | } 92 | 93 | /*****************************************************************************/ 94 | /* Non Primitives */ 95 | /*****************************************************************************/ 96 | 97 | void HeapWrite(const Heap *h, FILE *f) { 98 | fprintf(f, "["); 99 | for (int i = 0; i < h->size; ++i) { 100 | ElemWrite(HeapGetNodeValue(h, i), f); 101 | if (i != h->size - 1) { 102 | fprintf(f, ", "); 103 | } 104 | } 105 | fprintf(f, "]\n"); 106 | } 107 | 108 | void HeapWriteStdout(const Heap *h) { 109 | HeapWrite(h, stdout); 110 | } -------------------------------------------------------------------------------- /doublelist/doublelist.c: -------------------------------------------------------------------------------- 1 | #define _CRT_SECURE_NO_WARNINGS 2 | #include "doublelist.h" 3 | 4 | #include 5 | #include 6 | 7 | /*****************************************************************************/ 8 | /* Item & Primitives */ 9 | /*****************************************************************************/ 10 | 11 | Item *DListCreateEmpty(void) { 12 | return NULL; 13 | } 14 | 15 | Item *DListInsertHead(const ElemType *e, Item *i) { 16 | Item *n = malloc(sizeof(Item)); 17 | n->value = ElemCopy(e); 18 | n->next = i; 19 | n->prev = NULL; 20 | if (!DListIsEmpty(i)) { 21 | i->prev = n; 22 | } 23 | return n; 24 | } 25 | 26 | bool DListIsEmpty(const Item *i) { 27 | return i == NULL; 28 | } 29 | 30 | const ElemType *DListGetHeadValue(const Item *i) { 31 | if (DListIsEmpty(i)) { 32 | printf("ERROR: Alla funzione 'DListGetHead()' e' stata passata una lista vuota (NULL).\n"); 33 | exit(1); 34 | } 35 | else { 36 | return &i->value; 37 | } 38 | } 39 | 40 | Item *DListGetTail(const Item *i) { 41 | if (DListIsEmpty(i)) { 42 | printf("ERROR: Alla funzione 'ListGetTail()' e' stata passata una lista vuota (NULL).\n"); 43 | exit(2); 44 | } 45 | else { 46 | return i->next; 47 | } 48 | } 49 | 50 | Item* DListGetPrev(const Item* i) { 51 | if (DListIsEmpty(i)) { 52 | printf("ERROR: Alla funzione 'DListGetHead()' e' stata passata una lista vuota (NULL).\n"); 53 | exit(3); 54 | } 55 | else { 56 | return i->prev; 57 | } 58 | } 59 | 60 | Item *DListInsertBack(Item *i, const ElemType *e) { 61 | 62 | Item *n = DListInsertHead(e, DListCreateEmpty()); 63 | 64 | if (DListIsEmpty(i)) { 65 | return n; 66 | } 67 | 68 | Item *tmp = i; 69 | while (!DListIsEmpty(DListGetTail(tmp))) { 70 | tmp = DListGetTail(tmp); 71 | } 72 | 73 | tmp->next = n; 74 | n->prev = tmp; 75 | return i; 76 | } 77 | 78 | static const Item* DListGetFirst(const Item* i) { 79 | if (DListIsEmpty(i)) { 80 | return NULL; 81 | } 82 | 83 | while (!DListIsEmpty(i->prev)) { 84 | i = i->prev; 85 | } 86 | 87 | return i; 88 | } 89 | 90 | void DListDelete(Item *i) { 91 | 92 | i = (Item*)DListGetFirst(i); 93 | 94 | while (!DListIsEmpty(i)) { 95 | Item *tmp = i; 96 | i = i->next; 97 | ElemDelete(&tmp->value); 98 | free(tmp); 99 | } 100 | } 101 | 102 | /*****************************************************************************/ 103 | /* Non Primitives */ 104 | /*****************************************************************************/ 105 | 106 | void DListWrite(const Item *i, FILE *f) { 107 | 108 | i = DListGetFirst(i); 109 | 110 | fprintf(f, "["); 111 | while (!DListIsEmpty(i)) { 112 | ElemWrite(&i->value, f); 113 | i = DListGetTail(i); 114 | if (!DListIsEmpty(i)) { 115 | fprintf(f, ", "); 116 | } 117 | } 118 | fprintf(f, "]\n"); 119 | } 120 | 121 | void DListWriteStdout(const Item *i) { 122 | DListWrite(i, stdout); 123 | } -------------------------------------------------------------------------------- /elemtype/int/elemtype.h: -------------------------------------------------------------------------------- 1 | /** @file 2 | Questo file contiene la definizione di `ElemType` per il tipo `int` e la 3 | documentazione delle funzioni a esso associate. 4 | */ 5 | 6 | #ifndef ELEMTYPE_INT_H_ 7 | #define ELEMTYPE_INT_H_ 8 | 9 | #include 10 | #include 11 | 12 | /** @brief Definizione di `struct ElemType`. */ 13 | typedef int ElemType; 14 | 15 | /** @brief La funzione `ElemCompare()` confronta due elementi. 16 | 17 | @param[in] e1 Puntatore al primo elemento di cui eseguire il confronto. Il 18 | valore contenuto in `e1` non viene modificato. 19 | @param[in] e2 Puntatore al secondo elemento di cui eseguire il confronto. Il 20 | valore contenuto in `e2` non viene modificato. 21 | 22 | @return La funzione ritorna un valore intero che indica la relazione tra i due 23 | elementi, ovvero: 24 | - `< 0` (ad esempio `-1`) se il contenuto del primo è minore di quello del secondo; 25 | - `0` se i contenuti dei due elementi sono uguali; 26 | - `> 0` (ad esempio `1`) se il contenuto del primo è maggiore di quello del secondo. 27 | */ 28 | int ElemCompare(const ElemType *e1, const ElemType *e2); 29 | 30 | /** @brief La funzione `ElemCopy()` crea e ritorna una copia dell'elemento dato. 31 | 32 | @param[in] e Puntatore all'elemento da copiare. Il valore contenuto in `e` non 33 | viene modificato. 34 | 35 | @return Copia dell'elemento `e`. 36 | */ 37 | ElemType ElemCopy(const ElemType *e); 38 | 39 | /** @brief La funzione `ElemSwap()` scambia i due elementi specificati. 40 | 41 | @param[in] e1 Puntatore al primo elemento da scambiare. 42 | @param[in] e2 Puntatore al secondo elemento da scambiare. 43 | 44 | @return Non ci sono valori di ritorno. 45 | */ 46 | void ElemSwap(ElemType *e1, ElemType *e2); 47 | 48 | /** @brief La funzione `ElemDelete()` libera la memoria occupata dall'elemento 49 | specificato. 50 | 51 | @param[in] e Puntatore all'elemento di cui liberare la memoria. 52 | 53 | @return Non ci sono valori di ritorno. 54 | */ 55 | void ElemDelete(ElemType *e); 56 | 57 | /** @brief La funzione `ElemRead()` legge un elemento da file. 58 | 59 | @param[in] f `FILE *` da cui leggere un elemento. 60 | @param[out] e Elemento letto da file. 61 | 62 | @return Se la lettura va a buon fine la funzione ritorna `1`, altrimenti ritorna `0` 63 | in caso di errore di corrispondenza, errore di lettura o fine del file. Se 64 | si verifica un errore di lettura o si raggiunge la fine del file prima che 65 | qualunque dato possa essere letto correttamente la funzione ritorna EOF, 66 | ovvero un numero negativo. 67 | */ 68 | int ElemRead(FILE *f, ElemType *e); 69 | 70 | /** @brief La funzione `ElemReadStdin()` legge un elemento da `stdin`. 71 | 72 | @param[out] e Elemento letto da `stdin`. 73 | 74 | @return Se la lettura va a buon fine la funzione ritorna `1`, altrimenti ritorna `0` 75 | in caso di errore di corrispondenza, errore di lettura o fine del file. Se 76 | si verifica un errore di lettura o si raggiunge la fine del file prima che 77 | qualunque dato possa essere letto correttamente la funzione ritorna EOF, 78 | ovvero un numero negativo. 79 | */ 80 | int ElemReadStdin(ElemType *e); 81 | 82 | /** @brief La funzione `ElemWrite()` stampa un elemento su file. 83 | 84 | @param[in] e Puntatore all'elemento da stampare su file. Il valore contenuto in 85 | e non viene modificato. 86 | @param[in] f `FILE *` su cui stampare l'elemento. 87 | 88 | @return Non ci sono valori di ritorno. 89 | */ 90 | void ElemWrite(const ElemType *e, FILE *f); 91 | 92 | /** @brief La funzione `ElemWriteStdout()` stampa un elemento su `stdout`. 93 | 94 | @param[in] e Puntatore all'elemento da stampare su `stdout`. Il valore 95 | contenuto in `e` non viene modificato. 96 | 97 | @return Non ci sono valori di ritorno. 98 | */ 99 | void ElemWriteStdout(const ElemType *e); 100 | 101 | #endif // ELEMTYPE_INT_H_ 102 | 103 | -------------------------------------------------------------------------------- /elemtype/char/elemtype.h: -------------------------------------------------------------------------------- 1 | /** @file 2 | Questo file contiene la definizione di `ElemType` per il tipo `char` e la 3 | documentazione delle funzioni a esso associate. 4 | */ 5 | 6 | #ifndef ELEMTYPE_CHAR_H_ 7 | #define ELEMTYPE_CHAR_H_ 8 | 9 | #include 10 | #include 11 | 12 | /** @brief Definizione di `struct ElemType`. */ 13 | typedef char ElemType; 14 | 15 | /** @brief La funzione `ElemCompare()` confronta due elementi. 16 | 17 | @param[in] e1 Puntatore al primo elemento di cui eseguire il confronto. Il 18 | valore contenuto in `e1` non viene modificato. 19 | @param[in] e2 Puntatore al secondo elemento di cui eseguire il confronto. Il 20 | valore contenuto in `e2` non viene modificato. 21 | 22 | @return La funzione ritorna un valore intero che indica la relazione tra i due 23 | elementi, ovvero: 24 | - `< 0` (ad esempio `-1`) se il contenuto del primo è minore di quello del secondo; 25 | - `0` se i contenuti dei due elementi sono uguali; 26 | - `> 0` (ad esempio `1`) se il contenuto del primo è maggiore di quello del secondo. 27 | */ 28 | int ElemCompare(const ElemType *e1, const ElemType *e2); 29 | 30 | /** @brief La funzione `ElemCopy()` crea e ritorna una copia dell'elemento dato. 31 | 32 | @param[in] e Puntatore all'elemento da copiare. Il valore contenuto in `e` non 33 | viene modificato. 34 | 35 | @return Copia dell'elemento `e`. 36 | */ 37 | ElemType ElemCopy(const ElemType *e); 38 | 39 | /** @brief La funzione `ElemSwap()` scambia i due elementi specificati. 40 | 41 | @param[in] e1 Puntatore al primo elemento da scambiare. 42 | @param[in] e2 Puntatore al secondo elemento da scambiare. 43 | 44 | @return Non ci sono valori di ritorno. 45 | */ 46 | void ElemSwap(ElemType *e1, ElemType *e2); 47 | 48 | /** @brief La funzione `ElemDelete()` libera la memoria occupata dall'elemento 49 | specificato. 50 | 51 | @param[in] e Puntatore all'elemento di cui liberare la memoria. 52 | 53 | @return Non ci sono valori di ritorno. 54 | */ 55 | void ElemDelete(ElemType *e); 56 | 57 | /** @brief La funzione `ElemRead()` legge un elemento da file. 58 | 59 | @param[in] f `FILE *` da cui leggere un elemento. 60 | @param[out] e Elemento letto da file. 61 | 62 | @return Se la lettura va a buon fine la funzione ritorna `1`, altrimenti ritorna `0` 63 | in caso di errore di corrispondenza, errore di lettura o fine del file. Se 64 | si verifica un errore di lettura o si raggiunge la fine del file prima che 65 | qualunque dato possa essere letto correttamente la funzione ritorna EOF, 66 | ovvero un numero negativo. 67 | */ 68 | int ElemRead(FILE *f, ElemType *e); 69 | 70 | /** @brief La funzione `ElemReadStdin()` legge un elemento da `stdin`. 71 | 72 | @param[out] e Elemento letto da `stdin`. 73 | 74 | @return Se la lettura va a buon fine la funzione ritorna `1`, altrimenti ritorna `0` 75 | in caso di errore di corrispondenza, errore di lettura o fine del file. Se 76 | si verifica un errore di lettura o si raggiunge la fine del file prima che 77 | qualunque dato possa essere letto correttamente la funzione ritorna EOF, 78 | ovvero un numero negativo. 79 | */ 80 | int ElemReadStdin(ElemType *e); 81 | 82 | /** @brief La funzione `ElemWrite()` stampa un elemento su file. 83 | 84 | @param[in] e Puntatore all'elemento da stampare su file. Il valore contenuto in 85 | e non viene modificato. 86 | @param[in] f `FILE *` su cui stampare l'elemento. 87 | 88 | @return Non ci sono valori di ritorno. 89 | */ 90 | void ElemWrite(const ElemType *e, FILE *f); 91 | 92 | /** @brief La funzione `ElemWriteStdout()` stampa un elemento su `stdout`. 93 | 94 | @param[in] e Puntatore all'elemento da stampare su `stdout`. Il valore 95 | contenuto in `e` non viene modificato. 96 | 97 | @return Non ci sono valori di ritorno. 98 | */ 99 | void ElemWriteStdout(const ElemType *e); 100 | 101 | #endif // ELEMTYPE_CHAR_H_ 102 | 103 | -------------------------------------------------------------------------------- /tree/tree.c: -------------------------------------------------------------------------------- 1 | #define _CRT_SECURE_NO_WARNINGS 2 | #include "tree.h" 3 | 4 | #include 5 | #include 6 | 7 | /*****************************************************************************/ 8 | /* Node & Primitives */ 9 | /*****************************************************************************/ 10 | 11 | Node *TreeCreateEmpty(void) { 12 | return NULL; 13 | } 14 | 15 | Node *TreeCreateRoot(const ElemType *e, Node *l, Node *r) { 16 | Node *t = malloc(sizeof(Node)); 17 | t->value = ElemCopy(e); 18 | t->left = l; 19 | t->right = r; 20 | return t; 21 | } 22 | 23 | bool TreeIsEmpty(const Node *n) { 24 | return n == NULL; 25 | } 26 | 27 | const ElemType *TreeGetRootValue(const Node *n) { 28 | if (TreeIsEmpty(n)) { 29 | printf("ERROR: Alla funzione 'GetRootValueTree()' e' stato passato un albero vuoto (NULL).\n"); 30 | exit(1); 31 | } 32 | else { 33 | return &n->value; 34 | } 35 | } 36 | 37 | Node *TreeLeft(const Node *n) { 38 | if (TreeIsEmpty(n)) { 39 | return NULL; 40 | } 41 | else { 42 | return n->left; 43 | } 44 | } 45 | 46 | Node *TreeRight(const Node *n) { 47 | if (TreeIsEmpty(n)) { 48 | return NULL; 49 | } 50 | else { 51 | return n->right; 52 | } 53 | } 54 | 55 | bool TreeIsLeaf(const Node *n) { 56 | return TreeLeft(n) == NULL && TreeRight(n) == NULL; 57 | } 58 | 59 | void TreeDelete(Node *n) { 60 | if (TreeIsEmpty(n)) { 61 | return; 62 | } 63 | 64 | Node *l = TreeLeft(n); 65 | Node *r = TreeRight(n); 66 | 67 | ElemDelete(&n->value); 68 | 69 | free(n); 70 | 71 | TreeDelete(l); 72 | TreeDelete(r); 73 | } 74 | 75 | /*****************************************************************************/ 76 | /* Non Primitives */ 77 | /*****************************************************************************/ 78 | 79 | static void TreeWritePreOrderRec(const Node *n, FILE *f) { 80 | if (TreeIsEmpty(n)) { 81 | return; 82 | } 83 | 84 | fprintf(f, "\t"); ElemWrite(TreeGetRootValue(n), f); 85 | TreeWritePreOrderRec(TreeLeft(n), f); 86 | TreeWritePreOrderRec(TreeRight(n), f); 87 | } 88 | 89 | void TreeWritePreOrder(const Node *n, FILE *f) { 90 | fprintf(f, "Albero in PreOrdine: "); 91 | if (TreeIsEmpty(n)) { 92 | fprintf(f, "vuoto!"); 93 | } 94 | else { 95 | TreeWritePreOrderRec(n, f); 96 | } 97 | fprintf(f, "\n"); 98 | } 99 | 100 | void TreeWriteStdoutPreOrder(const Node *n) { 101 | TreeWritePreOrder(n, stdout); 102 | } 103 | 104 | static void TreeWriteInOrderRec(const Node *n, FILE *f) { 105 | if (TreeIsEmpty(n)) { 106 | return; 107 | } 108 | 109 | TreeWriteInOrderRec(TreeLeft(n), f); 110 | 111 | fprintf(f, "\t"); ElemWrite(TreeGetRootValue(n), f); 112 | 113 | TreeWriteInOrderRec(TreeRight(n), f); 114 | 115 | } 116 | 117 | void TreeWriteInOrder(const Node *n, FILE *f) { 118 | fprintf(f, "Albero in Ordine: "); 119 | if (TreeIsEmpty(n)) { 120 | fprintf(f, "vuoto!"); 121 | } 122 | else { 123 | TreeWriteInOrderRec(n, f); 124 | } 125 | fprintf(f, "\n"); 126 | } 127 | 128 | void TreeWriteStdoutInOrder(const Node *n) { 129 | TreeWriteInOrder(n, stdout); 130 | } 131 | 132 | static void TreeWritePostOrderRec(const Node *n, FILE *f) { 133 | if (TreeIsEmpty(n)) { 134 | return; 135 | } 136 | 137 | TreeWritePostOrderRec(TreeLeft(n), f); 138 | TreeWritePostOrderRec(TreeRight(n), f); 139 | 140 | fprintf(f, "\t"); ElemWrite(TreeGetRootValue(n), f); 141 | } 142 | 143 | void TreeWritePostOrder(const Node *n, FILE *f) { 144 | fprintf(f, "Albero in PostOrdine: "); 145 | if (TreeIsEmpty(n)) { 146 | fprintf(f, "vuoto!"); 147 | } 148 | else { 149 | TreeWritePostOrderRec(n, f); 150 | } 151 | fprintf(f, "\n"); 152 | } 153 | 154 | void TreeWriteStdoutPostOrder(const Node *n) { 155 | TreeWritePostOrder(n, stdout); 156 | } -------------------------------------------------------------------------------- /scripts/generate_doc.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | echo 'Setting up the script...' 3 | 4 | # Get the current gh-pages branch 5 | mkdir gh-pages 6 | echo $(pwd) 7 | 8 | # Load the list of things to be documented: data structure + elemtype 9 | doxyfiles=$(cat scripts/conf_complete.txt) 10 | echo '******' 11 | echo $doxyfiles 12 | echo '******' 13 | 14 | ################################################################################ 15 | ##### Generate the Doxygen documentation (from master) and log the output. ##### 16 | echo 'Generating Doxygen code documentation...' 17 | 18 | cwd=$(pwd) 19 | for i in $doxyfiles; do 20 | echo "****************************************************" 21 | echo "* $i" 22 | echo "****************************************************" 23 | 24 | # Let's copy the required source and header files for generating the current doc 25 | echo "cp $i/../*.* $i" 26 | cp $i/../*.* $i 27 | type_name=$(basename $i) 28 | echo "cp elemtype/$type_name/*.* $i" 29 | cp elemtype/$type_name/*.* $i 30 | 31 | # Redirect both stderr and stdout to the log file and the console. 32 | cd $i/doxygen 33 | doxygen 2>&1 | tee doxygen.log 34 | echo $(ls -l) 35 | cd $cwd 36 | 37 | ################################################################################ 38 | ##### Copy generated doc from master folder to gh-pages one. ##### 39 | dir=gh-pages/$i/html 40 | if [ -d "$dir" ]; then rm -Rf $dir; fi 41 | mkdir -p $dir 42 | mv $i/doxygen/html gh-pages/$i 43 | 44 | ################################################################################ 45 | ##### Creation of the zip file for the download. ##### 46 | cd $i 47 | headers=$(ls -I homepage.h | egrep '*.h$') 48 | sources=$(ls *.c) 49 | 50 | zip_name="${i//\//_}.zip" 51 | echo ${zip_name} 52 | zip ${zip_name} -r ${headers} ${sources} 53 | 54 | file=../../gh-pages/$i/${zip_name} 55 | if [ -f "$file" ]; then rm $file; fi 56 | mv ${zip_name} ${file} 57 | cd $cwd 58 | done 59 | 60 | # Load the list of things to be documented: only data structures 61 | doxyfiles=$(cat scripts/conf_datastruct.txt) 62 | echo '******' 63 | echo $doxyfiles 64 | echo '******' 65 | 66 | cwd=$(pwd) 67 | for i in $doxyfiles; do 68 | echo "****************************************************" 69 | echo "* $i" 70 | echo "****************************************************" 71 | 72 | # Redirect both stderr and stdout to the log file and the console. 73 | cd $i/doxygen 74 | doxygen 2>&1 | tee doxygen.log 75 | echo $(ls -l) 76 | cd $cwd 77 | 78 | ################################################################################ 79 | ##### Copy generated doc from master folder to gh-pages one. ##### 80 | dir=gh-pages/$i/html 81 | if [ -d "$dir" ]; then rm -Rf $dir; fi 82 | mkdir -p $dir 83 | mv $i/doxygen/html gh-pages/$i 84 | 85 | ################################################################################ 86 | ##### Creation of the zip file for the download. ##### 87 | cd $i 88 | headers=$(ls *.h) 89 | sources=$(ls *.c) 90 | 91 | zip_name="${i}.zip" 92 | echo ${zip_name} 93 | zip ${zip_name} -r ${headers} ${sources} 94 | 95 | file=../gh-pages/$i/${zip_name} 96 | if [ -f "$file" ]; then rm $file; fi 97 | mv ${zip_name} ${file} 98 | cd $cwd 99 | done 100 | 101 | # Load the list of things to be documented: only elemtypes 102 | doxyfiles=$(cat scripts/conf_elemtype.txt) 103 | echo '******' 104 | echo $doxyfiles 105 | echo '******' 106 | 107 | cwd=$(pwd) 108 | for i in $doxyfiles; do 109 | echo "****************************************************" 110 | echo "* $i" 111 | echo "****************************************************" 112 | 113 | # Redirect both stderr and stdout to the log file and the console. 114 | cd elemtype/$i/doxygen 115 | doxygen 2>&1 | tee doxygen.log 116 | echo $(ls -l) 117 | cd $cwd 118 | 119 | ################################################################################ 120 | ##### Copy generated doc from master folder to gh-pages one. ##### 121 | dir=gh-pages/elemtype/$i/html 122 | if [ -d "$dir" ]; then rm -Rf $dir; fi 123 | mkdir -p $dir 124 | mv elemtype/$i/doxygen/html gh-pages/elemtype/$i 125 | 126 | ################################################################################ 127 | ##### Creation of the zip file for the download. ##### 128 | cd elemtype/$i 129 | headers=$(ls *.h) 130 | sources=$(ls *.c) 131 | 132 | zip_name="elemtype_${i}.zip" 133 | echo ${zip_name} 134 | zip ${zip_name} -r ${headers} ${sources} 135 | 136 | file=../../gh-pages/elemtype/$i/${zip_name} 137 | if [ -f "$file" ]; then rm $file; fi 138 | mv ${zip_name} ${file} 139 | cd $cwd 140 | done 141 | 142 | echo $(ls -l gh-pages) -------------------------------------------------------------------------------- /list/int/examples/additional_op.c: -------------------------------------------------------------------------------- 1 | /** @example load.c 2 | * In questo esempio si illustrano implementazioni di diverse operazioni su liste, 3 | * come ad esempio il calcolo della sua lunghezza, la rimozione di un elemento, ecc. 4 | */ 5 | // Per controllare eventuali memory leak 6 | //#define _CRTDBG_MAP_ALLOC 7 | //#include 8 | //#include 9 | #include "list.h" 10 | 11 | #include 12 | 13 | /*****************************************************************************/ 14 | /* IS MEMBER */ 15 | /*****************************************************************************/ 16 | 17 | bool ListIsMember(const ElemType *e, Item* i) { 18 | while (!ListIsEmpty(i)) { 19 | if (ElemCompare(e, ListGetHeadValue(i)) == 0) { 20 | return true; 21 | } 22 | 23 | i = ListGetTail(i); 24 | } 25 | return false; 26 | } 27 | 28 | bool ListIsMemberRec(const ElemType *e, Item* i) { 29 | if (ListIsEmpty(i)) { 30 | return false; 31 | } 32 | 33 | if (ElemCompare(e, ListGetHeadValue(i)) == 0) { 34 | return true; 35 | } 36 | 37 | return ListIsMemberRec(e, ListGetTail(i)); 38 | } 39 | 40 | /*****************************************************************************/ 41 | /* LENGHT */ 42 | /*****************************************************************************/ 43 | int ListLength(Item *i) { 44 | int n = 0; 45 | while (!ListIsEmpty(i)) { 46 | n++; 47 | i = ListGetTail(i); 48 | } 49 | return n; 50 | } 51 | 52 | int ListLengthRec(Item *i) { 53 | if (ListIsEmpty(i)) { 54 | return 0; 55 | } 56 | 57 | return 1 + ListLengthRec(ListGetTail(i)); 58 | } 59 | 60 | /*****************************************************************************/ 61 | /* APPEND */ 62 | /*****************************************************************************/ 63 | Item *ListAppendRec(Item *i1, Item *i2) { 64 | if (ListIsEmpty(i1)) { 65 | return i2; 66 | } 67 | 68 | Item* tmp = ListInsertHead(ListGetHeadValue(i1), ListAppendRec(ListGetTail(i1), i2)); 69 | free(i1); 70 | return tmp; 71 | } 72 | 73 | /*****************************************************************************/ 74 | /* COPY */ 75 | /*****************************************************************************/ 76 | Item *ListCopyRec(Item *i) { 77 | if (ListIsEmpty(i)) { 78 | return i; 79 | } 80 | return ListInsertHead(ListGetHeadValue(i), ListCopyRec(ListGetTail(i))); 81 | } 82 | 83 | /*****************************************************************************/ 84 | /* REMOVE */ 85 | /*****************************************************************************/ 86 | Item *ListRemoveRec(const ElemType *e, Item *i) { 87 | if (ListIsEmpty(i)) { 88 | return i; 89 | } 90 | 91 | if (ElemCompare(e, ListGetHeadValue(i)) == 0) { 92 | Item *tmp = ListGetTail(i); 93 | free(i); 94 | return tmp; 95 | } 96 | 97 | Item *tmp = ListInsertHead(ListGetHeadValue(i), ListRemoveRec(e, ListGetTail(i))); 98 | free(i); 99 | return tmp; 100 | } 101 | 102 | Item *ListCreateFromVector(const int *v, size_t v_size) { 103 | Item *list = ListCreateEmpty(); 104 | for (size_t i = 0; i < v_size; ++i) { 105 | list = ListInsertBack(list, &v[i]); 106 | } 107 | return list; 108 | } 109 | 110 | int main(void) { 111 | int v[] = { 1,2,3,4,5,6,7,8,9 }; 112 | size_t v_size = sizeof(v) / sizeof(int); 113 | Item *list = ListCreateFromVector(v, v_size); 114 | Item *other_list = ListCreateFromVector(v, v_size - 5); 115 | 116 | ElemType e; 117 | bool ret; 118 | 119 | e = 5; 120 | ret = ListIsMember(&e, list); 121 | ret = ListIsMemberRec(&e, list); 122 | e = 11; 123 | ret = ListIsMember(&e, list); 124 | ret = ListIsMemberRec(&e, list); 125 | 126 | int len; 127 | len = ListLength(list); 128 | len = ListLengthRec(list); 129 | 130 | ListWriteStdout(list); 131 | ListWriteStdout(other_list); 132 | list = ListAppendRec(list, other_list); 133 | ListWriteStdout(list); 134 | 135 | other_list = ListCopyRec(list); 136 | ListWriteStdout(other_list); 137 | 138 | e = 1; 139 | list = ListRemoveRec(&e, list); 140 | ListWriteStdout(list); 141 | 142 | e = 5; 143 | list = ListRemoveRec(&e, list); 144 | ListWriteStdout(list); 145 | 146 | ListDelete(list); 147 | ListDelete(other_list); 148 | 149 | // Per controllare eventuali memory leak 150 | //_CrtDumpMemoryLeaks(); 151 | 152 | return EXIT_SUCCESS; 153 | } -------------------------------------------------------------------------------- /list/char/examples/additional_op.c: -------------------------------------------------------------------------------- 1 | /** @example load.c 2 | * In questo esempio si illustrano implementazioni di diverse operazioni su liste, 3 | * come ad esempio il calcolo della sua lunghezza, la rimozione di un elemento, ecc. 4 | */ 5 | // Per controllare eventuali memory leak 6 | //#define _CRTDBG_MAP_ALLOC 7 | //#include 8 | //#include 9 | #include "list.h" 10 | 11 | #include 12 | 13 | /*****************************************************************************/ 14 | /* IS MEMBER */ 15 | /*****************************************************************************/ 16 | 17 | bool ListIsMember(const ElemType *e, Item* i) { 18 | while (!ListIsEmpty(i)) { 19 | if (ElemCompare(e, ListGetHeadValue(i)) == 0) { 20 | return true; 21 | } 22 | 23 | i = ListGetTail(i); 24 | } 25 | return false; 26 | } 27 | 28 | bool ListIsMemberRec(const ElemType *e, Item* i) { 29 | if (ListIsEmpty(i)) { 30 | return false; 31 | } 32 | 33 | if (ElemCompare(e, ListGetHeadValue(i)) == 0) { 34 | return true; 35 | } 36 | 37 | return ListIsMemberRec(e, ListGetTail(i)); 38 | } 39 | 40 | /*****************************************************************************/ 41 | /* LENGHT */ 42 | /*****************************************************************************/ 43 | int ListLength(Item *i) { 44 | int n = 0; 45 | while (!ListIsEmpty(i)) { 46 | n++; 47 | i = ListGetTail(i); 48 | } 49 | return n; 50 | } 51 | 52 | int ListLengthRec(Item *i) { 53 | if (ListIsEmpty(i)) { 54 | return 0; 55 | } 56 | 57 | return 1 + ListLengthRec(ListGetTail(i)); 58 | } 59 | 60 | /*****************************************************************************/ 61 | /* APPEND */ 62 | /*****************************************************************************/ 63 | Item *ListAppendRec(Item *i1, Item *i2) { 64 | if (ListIsEmpty(i1)) { 65 | return i2; 66 | } 67 | 68 | Item* tmp = ListInsertHead(ListGetHeadValue(i1), ListAppendRec(ListGetTail(i1), i2)); 69 | free(i1); 70 | return tmp; 71 | } 72 | 73 | /*****************************************************************************/ 74 | /* COPY */ 75 | /*****************************************************************************/ 76 | Item *ListCopyRec(Item *i) { 77 | if (ListIsEmpty(i)) { 78 | return i; 79 | } 80 | return ListInsertHead(ListGetHeadValue(i), ListCopyRec(ListGetTail(i))); 81 | } 82 | 83 | /*****************************************************************************/ 84 | /* REMOVE */ 85 | /*****************************************************************************/ 86 | Item *ListRemoveRec(const ElemType *e, Item *i) { 87 | if (ListIsEmpty(i)) { 88 | return i; 89 | } 90 | 91 | if (ElemCompare(e, ListGetHeadValue(i)) == 0) { 92 | Item *tmp = ListGetTail(i); 93 | free(i); 94 | return tmp; 95 | } 96 | 97 | Item *tmp = ListInsertHead(ListGetHeadValue(i), ListRemoveRec(e, ListGetTail(i))); 98 | free(i); 99 | return tmp; 100 | } 101 | 102 | Item *ListCreateFromVector(const ElemType*v, size_t v_size) { 103 | Item *list = ListCreateEmpty(); 104 | for (size_t i = 0; i < v_size; ++i) { 105 | list = ListInsertBack(list, &v[i]); 106 | } 107 | return list; 108 | } 109 | 110 | int main(void) { 111 | ElemType v[] = { 1,2,3,4,5,6,7,8,9 }; 112 | size_t v_size = sizeof(v) / sizeof(ElemType); 113 | Item *list = ListCreateFromVector(v, v_size); 114 | Item *other_list = ListCreateFromVector(v, v_size - 5); 115 | 116 | ElemType e; 117 | bool ret; 118 | 119 | e = 5; 120 | ret = ListIsMember(&e, list); 121 | ret = ListIsMemberRec(&e, list); 122 | e = 11; 123 | ret = ListIsMember(&e, list); 124 | ret = ListIsMemberRec(&e, list); 125 | 126 | int len; 127 | len = ListLength(list); 128 | len = ListLengthRec(list); 129 | 130 | ListWriteStdout(list); 131 | ListWriteStdout(other_list); 132 | list = ListAppendRec(list, other_list); 133 | ListWriteStdout(list); 134 | 135 | other_list = ListCopyRec(list); 136 | ListWriteStdout(other_list); 137 | 138 | e = 1; 139 | list = ListRemoveRec(&e, list); 140 | ListWriteStdout(list); 141 | 142 | e = 5; 143 | list = ListRemoveRec(&e, list); 144 | ListWriteStdout(list); 145 | 146 | ListDelete(list); 147 | ListDelete(other_list); 148 | 149 | // Per controllare eventuali memory leak 150 | //_CrtDumpMemoryLeaks(); 151 | 152 | return EXIT_SUCCESS; 153 | } -------------------------------------------------------------------------------- /elemtype/int_vector/elemtype.h: -------------------------------------------------------------------------------- 1 | /** @file 2 | Questo file contiene la definizione di `ElemType` per il tipo `int vector` e la 3 | documentazione delle funzioni a esso associate. 4 | */ 5 | 6 | #ifndef ELEMTYPE_INT_VECTOR_H_ 7 | #define ELEMTYPE_INT_VECTOR_H_ 8 | 9 | #include 10 | #include 11 | 12 | /** @brief Definizione di `struct ElemType`. */ 13 | struct ElemType{ 14 | int *data; /*!< Puntatore ai dati del vettore. */ 15 | size_t size; /*!< Dimensione del vettore, ovvero numero di `int` che questo contiene. */ 16 | }; 17 | /** @brief Definizione di un nome alternativo per `struct ElemType`. */ 18 | typedef struct ElemType ElemType; 19 | 20 | /** @brief La funzione `ElemCompare()` confronta due elementi utilizzando una 21 | definizione di ordinameto per i "vettori di int" analoga a quella 22 | definita per le stringe C. 23 | 24 | @param[in] e1 Puntatore al primo elemento di cui eseguire il confronto. Il 25 | valore contenuto in `e1` non viene modificato. 26 | @param[in] e2 Puntatore al secondo elemento di cui eseguire il confronto. Il 27 | valore contenuto in `e2` non viene modificato. 28 | 29 | @return La funzione ritorna un valore intero che indica la relazione tra i due 30 | elementi, ovvero: 31 | - `< 0` (ad esempio `-1`) se il contenuto del primo è minore di quello del secondo, ovvero 32 | se il primo valore che non corrisponde è più piccolo in `e1` che in `e2`; 33 | - `0` se i contenuti dei due vettori sono uguali; 34 | - `> 0` (ad esempio `1`) se il contenuto del primo è maggiore di quello del secondo, ovvero 35 | se il primo valore che non corrisponde è più grande in `e1` che in `e2`. 36 | */ 37 | int ElemCompare(const ElemType *e1, const ElemType *e2); 38 | 39 | /** @brief La funzione `ElemCopy()` crea e ritorna una copia dell'elemento dato. 40 | 41 | @param[in] e Puntatore all'elemento da copiare. Il valore contenuto in `e` non 42 | viene modificato. 43 | 44 | @return Copia dell'elemento `e`. 45 | */ 46 | ElemType ElemCopy(const ElemType *e); 47 | 48 | /** @brief La funzione `ElemSwap()` scambia i due elementi specificati. 49 | 50 | @param[in] e1 Puntatore al primo elemento da scambiare. 51 | @param[in] e2 Puntatore al secondo elemento da scambiare. 52 | 53 | @return Non ci sono valori di ritorno. 54 | */ 55 | void ElemSwap(ElemType *e1, ElemType *e2); 56 | 57 | /** @brief La funzione `ElemDelete()` libera la memoria occupata dall'elemento 58 | specificato. 59 | 60 | @param[in] e Puntatore all'elemento di cui liberare la memoria. 61 | 62 | @return Non ci sono valori di ritorno. 63 | */ 64 | void ElemDelete(ElemType *e); 65 | 66 | /** @brief La funzione `ElemRead()` legge un elemento da file, ovvero legge la sua 67 | `size` e, dopo aver allocato spazio a sufficienza, legge `size` interi 68 | scrivendoli nel vettore puntato da `data`. 69 | 70 | @param[in] f `FILE *` da cui leggere un elemento. 71 | @param[out] e Elemento letto da file. 72 | 73 | @return Se la lettura va a buon fine la funzione ritorna `1`, altrimenti ritorna `0` 74 | in caso di errore di corrispondenza, errore di lettura o fine del file. Se 75 | si verifica un errore di lettura o si raggiunge la fine del file prima che 76 | qualunque dato possa essere letto correttamente la funzione ritorna EOF, 77 | ovvero un numero negativo. 78 | */ 79 | int ElemRead(FILE *f, ElemType *e); 80 | 81 | /** @brief La funzione `ElemReadStdin()` legge un elemento da `stdin`, 82 | ovvero legge la sua `size` e, dopo aver alloca spazio a sufficienza, 83 | legge `size` interi scrivendoli nel vettore puntato da `data`. 84 | 85 | 86 | @param[out] e Elemento letto da `stdin`. 87 | 88 | @return Se la lettura va a buon fine la funzione ritorna `1`, altrimenti ritorna `0` 89 | in caso di errore di corrispondenza, errore di lettura o fine del file. Se 90 | si verifica un errore di lettura o si raggiunge la fine del file prima che 91 | qualunque dato possa essere letto correttamente la funzione ritorna EOF, 92 | ovvero un numero negativo. 93 | */ 94 | int ElemReadStdin(ElemType *e); 95 | 96 | /** @brief La funzione `ElemWrite()` stampa un elemento su file. 97 | 98 | @param[in] e Puntatore all'elemento da stampare su file. Il valore contenuto in 99 | e non viene modificato. 100 | @param[in] f `FILE *` su cui stampare l'elemento. 101 | 102 | @return Non ci sono valori di ritorno. 103 | */ 104 | void ElemWrite(const ElemType *e, FILE *f); 105 | 106 | /** @brief La funzione `ElemWriteStdout()` stampa un elemento su `stdout`. 107 | 108 | @param[in] e Puntatore all'elemento da stampare su `stdout`. Il valore 109 | contenuto in e non viene modificato. 110 | 111 | @return Non ci sono valori di ritorno. 112 | */ 113 | void ElemWriteStdout(const ElemType *e); 114 | 115 | 116 | #endif // ELEMTYPE_INT_VECTOR_H_ 117 | 118 | -------------------------------------------------------------------------------- /list/list.h: -------------------------------------------------------------------------------- 1 | /** @file 2 | Questo file contiene la definizione del tipo `Item` e la documentazione delle 3 | funzioni primitive (e non) relative alle liste. Si noti che il comportamento di 4 | queste funzioni è indipendente dalla definizione di `ElemType`. 5 | */ 6 | 7 | #ifndef LIST_H_ 8 | #define LIST_H_ 9 | 10 | #include "elemtype.h" 11 | 12 | #include 13 | #include 14 | 15 | /*****************************************************************************/ 16 | /* Item & Primitives */ 17 | /*****************************************************************************/ 18 | 19 | /** @brief Definizione del tipo `struct Item`. */ 20 | struct Item { 21 | ElemType value; /*!< Valore associato all'`Item`. */ 22 | struct Item *next; /*!< Puntatore all'`Item` successivo. */ 23 | }; 24 | /** @brief Definizione di un nome alternativo per `struct Item`. */ 25 | typedef struct Item Item; 26 | 27 | /** @brief La funzione `ListCreateEmpty()` crea e ritorna una lista vuota, ovvero 28 | `NULL`. 29 | 30 | @return Lista vuota (`NULL`). 31 | */ 32 | Item *ListCreateEmpty(void); 33 | 34 | /** @brief La funzione `ListInsertHead()` aggiunge un nuovo elemento in testa ad 35 | una lista e ritorna il puntatore alla nuova lista. 36 | 37 | @param[in] e Puntatore all'elemento da aggiugnere in testa alla lista. 38 | @param[in] i Lista a cui aggiungere il nuovo elemento. `i` può essere una lista 39 | vuota (NULL). 40 | 41 | @return Lista risultante. 42 | */ 43 | Item *ListInsertHead(const ElemType *e, Item *i); 44 | 45 | /** @brief La funzione `ListIsEmpty(`) verifica se una lista è vuota. 46 | 47 | @param[in] i Lista su cui eseguire la verifica. 48 | 49 | @return `true` se la lista è vuota, `false` altrimenti. 50 | */ 51 | bool ListIsEmpty(const Item *i); 52 | 53 | /** @brief La funzione `ListGetHead()` ritorna un puntatore all'elemento in testa 54 | alla lista, senza rimuoverlo. 55 | 56 | @param[in] i Lista da cui estrarre il valore in testa. Questa lista non può 57 | essere vuota, nel caso in cui lo sia la funzione termina il programma 58 | con codice di errore `1`. 59 | 60 | @returns Puntatore all'elemento (costante) in testa alla lista. 61 | */ 62 | const ElemType *ListGetHeadValue(const Item *i); 63 | 64 | /** @brief La funzione `ListGetTail()` ritorna la lista privata dell'elemento in 65 | testa. La funzione NON dealloca la memoria occupata dalla testa 66 | della lista. 67 | 68 | @param[in] i Lista da cui ottenere la coda. La lista non può essere vuota, 69 | nel caso in cui lo sia la funzione termina il programma con codice di 70 | errore `2`. 71 | 72 | @return Lista ottenuta dopo l'eliminazione della testa. Il valore di ritorno 73 | potrebbe essere una lista vuota (`NULL`). 74 | */ 75 | Item *ListGetTail(const Item *i); 76 | 77 | 78 | /** @brief La funzione `ListInsertBack()` aggiunge un elemento in coda ad una 79 | lista (anche vuota) e ritorna la lista risultante. 80 | 81 | @param[in] i Lista a cui aggiungere l'elemento specifciato. Questa lista può 82 | essere vuota (`NULL`). 83 | @param[in] e Puntatore all'elemento da aggiugnere in coda alla lista. Il valore 84 | contenuto in e non viene modificato. 85 | 86 | @return Lista ottenuta dopo l'aggiunta dell'elemento. 87 | */ 88 | Item *ListInsertBack(Item *i, const ElemType *e); 89 | 90 | /** @brief La funzione `ListDelete()` libera la memoria occupata dagli elementi di 91 | una lista. 92 | 93 | @param[in] i Lista di cui liberare la memoria, può essere vuota (`NULL`). 94 | 95 | @return Non ci sono valori di ritorno. 96 | */ 97 | void ListDelete(Item *i); 98 | 99 | /*****************************************************************************/ 100 | /* Non Primitives */ 101 | /*****************************************************************************/ 102 | 103 | /** @brief La funzione `ListWrite()` stampa la lista specificata su file. 104 | Nello specifico, la funzione stampa il carattere "[" seguito dagli 105 | elementi della lista, separati dai caratter ", ", e dal carattere "]". 106 | La stampa degli elementi dipende dalla definizione di `ElemType`. 107 | 108 | @param[in] i Lista da stampare su file: può essere vuota e non viene modificata. 109 | @param[in] f `FILE *` su cui stampare la lista. 110 | 111 | @return Non ci sono valori di ritorno. 112 | */ 113 | void ListWrite(const Item *i, FILE *f); 114 | 115 | /** @brief La funzione `ListWriteStdout()` stampa la lista specificata su `stdout`. 116 | Nello specifico, la funzione stampa il carattere "[" seguito dagli 117 | elementi della lista, separati dai caratter ", ", e dal carattere "]". 118 | La stampa degli elementi dipende dalla definizione di `ElemType`. 119 | 120 | @param[in] i Lista da stampare su `stdout`: può essere vuota e non viene modificata. 121 | 122 | @return Non ci sono valori di ritorno. 123 | */ 124 | void ListWriteStdout(const Item *i); 125 | 126 | #endif // LIST_H_ 127 | 128 | -------------------------------------------------------------------------------- /doublelist/doublelist.h: -------------------------------------------------------------------------------- 1 | /** @file 2 | Questo file contiene la definizione del tipo `Item` e la documentazione delle 3 | funzioni primitive (e non) relative alle liste doppiamente concatenate. Si noti 4 | che il comportamento di queste funzioni è indipendente dalla definizione di `ElemType`. 5 | */ 6 | 7 | #ifndef DOUBLELIST_H_ 8 | #define DOUBLELIST_H_ 9 | 10 | #include "elemtype.h" 11 | 12 | #include 13 | #include 14 | 15 | /*****************************************************************************/ 16 | /* Item & Primitive */ 17 | /*****************************************************************************/ 18 | 19 | /** @brief Definizione del tipo `struct Item`. */ 20 | struct Item { 21 | ElemType value; /*!< Valore associato all'`Item`. */ 22 | struct Item *next; /*!< Puntatore all'`Item` successivo. */ 23 | struct Item *prev; /*!< Puntatore all'`Item` precedente. */ 24 | }; 25 | /** @brief Definizione di un nome alternativo per `struct Item`. */ 26 | typedef struct Item Item; 27 | 28 | /** @brief La funzione `DListCreateEmpty()` crea e ritorna una lista vuota, ovvero 29 | `NULL`. 30 | 31 | @return Lista vuota (`NULL`). 32 | */ 33 | Item *DListCreateEmpty(void); 34 | 35 | /** @brief La funzione `DListInsertHead()` aggiunge un nuovo elemento in testa ad 36 | una lista e ritorna il puntatore alla nuova lista. 37 | 38 | @param[in] e Puntatore all'elemento da aggiugnere in testa alla lista. 39 | @param[in] i Lista a cui aggiungere il nuovo elemento. `i` può essere una lista 40 | vuota (NULL). 41 | 42 | @return Lista risultante. 43 | */ 44 | Item *DListInsertHead(const ElemType *e, Item *i); 45 | 46 | /** @brief La funzione `DListIsEmpty(`) verifica se una lista è vuota. 47 | 48 | @param[in] i Lista su cui eseguire la verifica. 49 | 50 | @return `true` se la lista è vuota, `false` altrimenti. 51 | */ 52 | bool DListIsEmpty(const Item *i); 53 | 54 | /** @brief La funzione `DListGetHead()` ritorna un puntatore all'elemento in testa 55 | alla lista, senza rimuoverlo. 56 | 57 | @param[in] i Lista da cui estrarre il valore in testa. Questa lista non può 58 | essere vuota, nel caso in cui lo sia la funzione termina il programma 59 | con codice di errore `1`. 60 | 61 | @returns Puntatore all'elemento (costante) in testa alla lista. 62 | */ 63 | const ElemType *DListGetHeadValue(const Item *i); 64 | 65 | /** @brief La funzione `DListGetTail()` ritorna la lista privata dell'elemento in 66 | testa. La funzione NON dealloca la memoria occupata dalla testa 67 | della lista. 68 | 69 | @param[in] i Lista da cui ottenere la coda. La lista non può essere vuota, 70 | nel caso in cui lo sia la funzione termina il programma con codice di 71 | errore `2`. 72 | 73 | @return Lista ottenuta dopo l'eliminazione della testa. Il valore di ritorno 74 | potrebbe essere una lista vuota (`NULL`). 75 | */ 76 | Item *DListGetTail(const Item *i); 77 | 78 | /** @brief La funzione `DListGetPrev()` ritorna il puntatore all'elemento precedente. 79 | 80 | @param[in] i Lista da cui ottenere l'`Item` precedente. La lista non può essere vuota, 81 | nel caso in cui lo sia la funzione termina il programma con codice di 82 | errore `3`. 83 | 84 | @return Puntatore alla nuova testa della lista. Il valore di ritorno potrebbe essere 85 | una lista vuota (`NULL`). 86 | */ 87 | Item* DListGetPrev(const Item* i); 88 | 89 | /** @brief La funzione `DListInsertBack()` aggiunge un elemento in coda ad una 90 | lista (anche vuota) e ritorna la lista risultante. 91 | 92 | @param[in] i Lista a cui aggiungere l'elemento specifciato. Questa lista può 93 | essere vuota (`NULL`). 94 | @param[in] e Puntatore all'elemento da aggiugnere in coda alla lista. Il valore 95 | contenuto in e non viene modificato. 96 | 97 | @return Lista ottenuta dopo l'aggiunta dell'elemento. 98 | */ 99 | Item *DListInsertBack(Item *i, const ElemType *e); 100 | 101 | /** @brief La funzione `ListDelete()` libera la memoria occupata da tutti gli elementi 102 | di una lista, indipendentemente dalla posizione dell'`Item` specificato. 103 | 104 | La funzione `ListDelete()` prende in input un puntatore ad un elemento di una lista e 105 | libera la memoria occupata da tutti i suoi `Item`, quelli precedenti, quelli successivi 106 | e quello passato come input alla funzione. 107 | 108 | @param[in] i `Item` della lista di cui liberare la memoria, può essere `NULL`. 109 | 110 | @return Non ci sono valori di ritorno. 111 | */ 112 | void DListDelete(Item *i); 113 | 114 | /*****************************************************************************/ 115 | /* Non Primitive */ 116 | /*****************************************************************************/ 117 | 118 | /** @brief La funzione `DListWrite()` stampa la lista specificata su file. 119 | Nello specifico, la funzione stampa il carattere "[" seguito dagli 120 | elementi della lista, separati dai caratter ", ", e dal carattere "]". 121 | La stampa degli elementi dipende dalla definizione di `ElemType`. 122 | 123 | @param[in] i `Item` della lista da stampare su file: può essere NULL e non è necessario 124 | che sia l'`Item` in testa alla lista, la lista non viene modificata. 125 | @param[in] f `FILE *` su cui stampare la lista. 126 | 127 | @return Non ci sono valori di ritorno. 128 | */ 129 | void DListWrite(const Item *i, FILE *f); 130 | 131 | /** @brief La funzione `DListWriteStdout()` stampa la lista specificata su `stdout`. 132 | Nello specifico, la funzione stampa il carattere "[" seguito dagli 133 | elementi della lista, separati dai caratter ", ", e dal carattere "]". 134 | La stampa degli elementi dipende dalla definizione di `ElemType`. 135 | 136 | @param[in] i `Item` della lista da stampare su file: può essere NULL e non è necessario 137 | che sia l'`Item` in testa alla lista, la lista non viene modificata. 138 | 139 | @return Non ci sono valori di ritorno. 140 | */ 141 | void DListWriteStdout(const Item *i); 142 | 143 | #endif // DOUBLELIST_H_ 144 | 145 | -------------------------------------------------------------------------------- /maxheap/maxheap.h: -------------------------------------------------------------------------------- 1 | /** @file 2 | Questo file contiene la definizione del tipo `Heap` e la documentazione delle 3 | funzioni primitive (e non) relative alle code di priorità (heap). Si noti che il 4 | comportamento di queste funzioni è indipendente dalla definizione di `ElemType`. 5 | */ 6 | 7 | #ifndef MAXHEAP_H_ 8 | #define MAXHEAP_H_ 9 | 10 | #include "elemtype.h" 11 | 12 | #include 13 | #include 14 | 15 | /*****************************************************************************/ 16 | /* Node & Primitives */ 17 | /*****************************************************************************/ 18 | 19 | /** @brief Definizione del tipo `struct Heap`. */ 20 | struct Heap { 21 | ElemType *data; /*!< Vettore dei dati. */ 22 | size_t size; /*!< Dimensione del vettore dei dati, ovvero numero di `ElemType` che questo contiene. */ 23 | }; 24 | /** @brief Definizione di un nome alternativo per `struct Heap`. */ 25 | typedef struct Heap Heap; 26 | 27 | /** @brief Dato l'indice di un nodo della coda di priorità, la funzione `HeapLeft()` 28 | ritorna l'indice del suo figlio sinistro. 29 | 30 | @param[in] i Indice di un nodo della coda. 31 | 32 | @return Indice del figlio sinistro del nodo `i`. Non e' detto che il nodo avente 33 | l'indice ritornato sia effettivamente presente nella coda. 34 | */ 35 | int HeapLeft(int i); 36 | 37 | /** @brief Dato l'indice di un nodo della coda di priorità, la funzione `HeapRight()` 38 | ritorna l'indice del suo figlio destro. 39 | 40 | @param[in] i Indice di un nodo della coda. 41 | 42 | @return Indice del figlio destro del nodo `i`. Non è detto che il nodo avente 43 | l'indice ritornato sia effettivamente presente nella coda. 44 | */ 45 | int HeapRight(int i); 46 | 47 | /** @brief Dato l'indice di un nodo della coda di priorità, la funzione `HeapParent()` 48 | ritorna l'indice del nodo padre. 49 | 50 | @param[in] i Indice di un nodo della coda. 51 | 52 | @return Indice del padre del nodo `i`. Non è detto che il nodo avente l'indice 53 | ritornato sia effettivamente presente nella coda. 54 | */ 55 | int HeapParent(int i); 56 | 57 | /** @brief La funzione `HeapCreateEmpty()` crea e ritorna una coda di priorità 58 | vuota implementata mediante array. 59 | 60 | @return Puntatore allo heap appena creato. 61 | */ 62 | Heap* HeapCreateEmpty(); 63 | 64 | /** @brief La funzione `HeapMaxInsertNode()` aggiunge un nodo a una coda di 65 | priorità esistente, garantendo che le proprietà (max-)heap siano 66 | rispettate. 67 | 68 | @param[in] h (max-)heap. 69 | @param[in] e Valore da utilizzare per la creazione del nuovo nodo. 70 | 71 | @returns Non ci sono valori di ritorno. 72 | */ 73 | void HeapMaxInsertNode(Heap *h, const ElemType *e); 74 | 75 | /** @brief La funzione `HeapIsEmpty()` verifica se una coda di priorità esistente 76 | è vuota. 77 | 78 | @param[in] h Heap da testare. 79 | 80 | @return `true` se lo heap è vuoto, ovvero contiene zero elementi (`h->size == 0`), 81 | `false` altrimenti. 82 | */ 83 | bool HeapIsEmpty(const Heap *h); 84 | 85 | /** @brief La funzione `HeapGetNodeValue()` ritorna un puntatore all'elemento 86 | contenuto nel nodo di indice specificato. 87 | 88 | @param[in] h (max-)heap. 89 | @param[in] i Indice del nodo. 90 | 91 | @returns Puntatore all'elemento contenuto nel nodo di indice `i`. 92 | */ 93 | ElemType* HeapGetNodeValue(const Heap *h, int i); 94 | 95 | /** @brief Dato un heap e l'indice di un nodo, la funzione `HeapMaxMoveUp()` sposta 96 | il nodo verso l'alto, ovvero lo scambia con il nodo padre ricorsivamente 97 | fino a quando le condizione (max-)heap non sono rispettate. 98 | 99 | @param[i] h (max-)heap. Tutti i nodi di `h`, ad eccezione di quello di indice `i`, 100 | devono rispettare le condizioni (max-)heap. 101 | @param[i] i Indice del nodo su cui applicare la procedura. 102 | 103 | @return Non ci sono valori di ritorno. 104 | */ 105 | void HeapMaxMoveUp(Heap *h, int i); 106 | 107 | /** @brief Dato un heap e l'indice di un nodo, la funzione `HeapMaxMoveDown()` 108 | sposta il nodo verso il basso, ovvero lo scambia con il minore dei 109 | figli ricorsivamente fino a quando le condizione (max-)heap non sono 110 | rispettate. 111 | 112 | @param[i] h (max-)heap. Tutti i nodi di `h`, ad eccezione di quello di indice `i`, 113 | devono rispettare le condizioni (max-)heap. 114 | @param[i] i Indice del nodo su cui applicare la procedura. 115 | 116 | @return Non ci sono valori di ritorno. 117 | */ 118 | void HeapMaxMoveDown(Heap *h, int i); 119 | 120 | /** @brief La funzione `HeapDelete()` libera la memoria occupata dall'heap. 121 | 122 | @param[in] h Heap di cui liberare la memoria. 123 | 124 | @return Non ci sono valori di ritorno. 125 | */ 126 | void HeapDelete(Heap *h); 127 | 128 | /*****************************************************************************/ 129 | /* Non Primitives */ 130 | /*****************************************************************************/ 131 | 132 | /** @brief La funzione `HeapWrite()` stampa la coda di priorità su file. 133 | Nello specifico, la funzione stampa il carattere "[" seguito dagli 134 | elementi del vettore che implementa la coda di priorità, separati 135 | dai caratteri ", ". Infine viene stampato il carattere "]". 136 | La stampa degli elementi dipende dalla definizione di `ElemType`. 137 | 138 | @param[in] h Heap da stampare su file. Lo heap non viene modificato. 139 | @param[in] f `FILE *` su cui stampare lo heap. 140 | 141 | @return Non ci sono valori di ritorno. 142 | */ 143 | void HeapWrite(const Heap *h, FILE *f); 144 | 145 | /** @brief La funzione `HeapWriteStdout()` stampa lo heap specificato su `stdout`. 146 | Nello specifico, la funzione stampa il carattere "[" seguito dagli 147 | elementi del vettore che implementa la coda di priorità, separati 148 | dai caratteri ", ". Infine viene stampato il carattere "]". 149 | La stampa degli elementi dipende dalla definizione di `ElemType`. 150 | 151 | @param[in] h Heap da stampare su `stdout`. Lo heap non viene modificato. 152 | 153 | @return Non ci sono valori di ritorno. 154 | */ 155 | void HeapWriteStdout(const Heap *i); 156 | 157 | #endif // MAXHEAP_H_ 158 | 159 | -------------------------------------------------------------------------------- /minheap/minheap.h: -------------------------------------------------------------------------------- 1 | /** @file 2 | Questo file contiene la definizione del tipo `Heap` e la documentazione delle 3 | funzioni primitive (e non) relative alle code di priorità (heap). Si noti che il 4 | comportamento di queste funzioni è indipendente dalla definizione di `ElemType`. 5 | */ 6 | 7 | #ifndef MINHEAP_H_ 8 | #define MINHEAP_H_ 9 | 10 | #include "elemtype.h" 11 | 12 | #include 13 | #include 14 | 15 | /*****************************************************************************/ 16 | /* Node & Primitives */ 17 | /*****************************************************************************/ 18 | 19 | /** @brief Definizione del tipo `struct Heap`. */ 20 | struct Heap { 21 | ElemType *data; /*!< Vettore dei dati. */ 22 | size_t size; /*!< Dimensione del vettore dei dati, ovvero numero di `ElemType` che questo contiene. */ 23 | }; 24 | /** @brief Definizione di un nome alternativo per `struct Heap`. */ 25 | typedef struct Heap Heap; 26 | 27 | /** @brief Dato l'indice di un nodo della coda di priorità, la funzione `HeapLeft()` 28 | ritorna l'indice del suo figlio sinistro. 29 | 30 | @param[in] i Indice di un nodo della coda. 31 | 32 | @return Indice del figlio sinistro del nodo `i`. Non e' detto che il nodo avente 33 | l'indice ritornato sia effettivamente presente nella coda. 34 | */ 35 | int HeapLeft(int i); 36 | 37 | /** @brief Dato l'indice di un nodo della coda di priorità, la funzione `HeapRight()` 38 | ritorna l'indice del suo figlio destro. 39 | 40 | @param[in] i Indice di un nodo della coda. 41 | 42 | @return Indice del figlio destro del nodo `i`. Non è detto che il nodo avente 43 | l'indice ritornato sia effettivamente presente nella coda. 44 | */ 45 | int HeapRight(int i); 46 | 47 | /** @brief Dato l'indice di un nodo della coda di priorità, la funzione `HeapParent()` 48 | ritorna l'indice del nodo padre. 49 | 50 | @param[in] i Indice di un nodo della coda. 51 | 52 | @return Indice del padre del nodo `i`. Non è detto che il nodo avente l'indice 53 | ritornato sia effettivamente presente nella coda. 54 | */ 55 | int HeapParent(int i); 56 | 57 | /** @brief La funzione `HeapCreateEmpty()` crea e ritorna una coda di priorità 58 | vuota implementata mediante array. 59 | 60 | @return Puntatore allo heap appena creato. 61 | */ 62 | Heap* HeapCreateEmpty(); 63 | 64 | /** @brief La funzione `HeapMinInsertNode()` aggiunge un nodo a una coda di 65 | priorità esistente, garantendo che le proprietà (min-)heap siano 66 | rispettate. 67 | 68 | @param[in] h (min-)heap. 69 | @param[in] e Valore da utilizzare per la creazione del nuovo nodo. 70 | 71 | @returns Non ci sono valori di ritorno. 72 | */ 73 | void HeapMinInsertNode(Heap *h, const ElemType *e); 74 | 75 | /** @brief La funzione `HeapIsEmpty()` verifica se una coda di priorità esistente 76 | è vuota. 77 | 78 | @param[in] h Heap da testare. 79 | 80 | @return `true` se lo heap è vuoto, ovvero contiene zero elementi (`h->size == 0`), 81 | `false` altrimenti. 82 | */ 83 | bool HeapIsEmpty(const Heap *h); 84 | 85 | /** @brief La funzione `HeapGetNodeValue()` ritorna un puntatore all'elemento 86 | contenuto nel nodo di indice specificato. 87 | 88 | @param[in] h (min-)heap. 89 | @param[in] i Indice del nodo. 90 | 91 | @returns Puntatore all'elemento contenuto nel nodo di indice `i`. 92 | */ 93 | ElemType* HeapGetNodeValue(const Heap *h, int i); 94 | 95 | /** @brief Dato un heap e l'indice di un nodo, la funzione `HeapMinMoveUp()` sposta 96 | il nodo verso l'alto, ovvero lo scambia con il nodo padre ricorsivamente 97 | fino a quando le condizione (min-)heap non sono rispettate. 98 | 99 | @param[i] h (min-)heap. Tutti i nodi di `h`, ad eccezione di quello di indice `i`, 100 | devono rispettare le condizioni (min-)heap. 101 | @param[i] i Indice del nodo su cui applicare la procedura. 102 | 103 | @return Non ci sono valori di ritorno. 104 | */ 105 | void HeapMinMoveUp(Heap *h, int i); 106 | 107 | /** @brief Dato un heap e l'indice di un nodo, la funzione `HeapMinMoveDown()` 108 | sposta il nodo verso il basso, ovvero lo scambia con il minore dei 109 | figli ricorsivamente fino a quando le condizione (min-)heap non sono 110 | rispettate. 111 | 112 | @param[i] h (min-)heap. Tutti i nodi di `h`, ad eccezione di quello di indice `i`, 113 | devono rispettare le condizioni (min-)heap. 114 | @param[i] i Indice del nodo su cui applicare la procedura. 115 | 116 | @return Non ci sono valori di ritorno. 117 | */ 118 | void HeapMinMoveDown(Heap *h, int i); 119 | 120 | /** @brief La funzione `HeapDelete()` libera la memoria occupata dall'heap. 121 | 122 | @param[in] h Heap di cui liberare la memoria. 123 | 124 | @return Non ci sono valori di ritorno. 125 | */ 126 | void HeapDelete(Heap *h); 127 | 128 | /*****************************************************************************/ 129 | /* Non Primitives */ 130 | /*****************************************************************************/ 131 | 132 | /** @brief La funzione `HeapWrite()` stampa la coda di priorità su file. 133 | Nello specifico, la funzione stampa il carattere "[" seguito dagli 134 | elementi del vettore che implementa la coda di priorità, separati 135 | dai caratteri ", ". Infine viene stampato il carattere "]". 136 | La stampa degli elementi dipende dalla definizione di `ElemType`. 137 | 138 | @param[in] h Heap da stampare su file. Lo heap non viene modificato. 139 | @param[in] f `FILE *` su cui stampare lo heap. 140 | 141 | @return Non ci sono valori di ritorno. 142 | */ 143 | void HeapWrite(const Heap *h, FILE *f); 144 | 145 | /** @brief La funzione `HeapWriteStdout()` stampa lo heap specificato su `stdout`. 146 | Nello specifico, la funzione stampa il carattere "[" seguito dagli 147 | elementi del vettore che implementa la coda di priorità, separati 148 | dai caratteri ", ". Infine viene stampato il carattere "]". 149 | La stampa degli elementi dipende dalla definizione di `ElemType`. 150 | 151 | @param[in] h Heap da stampare su `stdout`. Lo heap non viene modificato. 152 | 153 | @return Non ci sono valori di ritorno. 154 | */ 155 | void HeapWriteStdout(const Heap *i); 156 | 157 | #endif // MINHEAP_H_ 158 | 159 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | #Doxygen generated files 2 | **/html 3 | 4 | # Ignore Visual Studio temporary files, build results, and files generated by popular Visual Studio add-ons. 5 | # Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore 6 | 7 | # User-specific files 8 | *.rsuser 9 | *.suo 10 | *.user 11 | *.userosscache 12 | *.sln.docstates 13 | 14 | # User-specific files (MonoDevelop/Xamarin Studio) 15 | *.userprefs 16 | 17 | # Mono auto generated files 18 | mono_crash.* 19 | 20 | # Build results 21 | [Dd]ebug/ 22 | [Dd]ebugPublic/ 23 | [Rr]elease/ 24 | [Rr]eleases/ 25 | x64/ 26 | x86/ 27 | [Ww][Ii][Nn]32/ 28 | [Aa][Rr][Mm]/ 29 | [Aa][Rr][Mm]64/ 30 | bld/ 31 | **/[Bb]in/ 32 | **/[Bb]uild/ 33 | [Oo]bj/ 34 | [Ll]og/ 35 | [Ll]ogs/ 36 | 37 | # Visual Studio 2015/2017 cache/options directory 38 | .vs/ 39 | # Uncomment if you have tasks that create the project's static files in wwwroot 40 | #wwwroot/ 41 | 42 | # Visual Studio 2017 auto generated files 43 | Generated\ Files/ 44 | 45 | # MSTest test Results 46 | [Tt]est[Rr]esult*/ 47 | [Bb]uild[Ll]og.* 48 | 49 | # NUnit 50 | *.VisualState.xml 51 | TestResult.xml 52 | nunit-*.xml 53 | 54 | # Build Results of an ATL Project 55 | [Dd]ebugPS/ 56 | [Rr]eleasePS/ 57 | dlldata.c 58 | 59 | # Benchmark Results 60 | BenchmarkDotNet.Artifacts/ 61 | 62 | # .NET Core 63 | project.lock.json 64 | project.fragment.lock.json 65 | artifacts/ 66 | 67 | # ASP.NET Scaffolding 68 | ScaffoldingReadMe.txt 69 | 70 | # StyleCop 71 | StyleCopReport.xml 72 | 73 | # Files built by Visual Studio 74 | *_i.c 75 | *_p.c 76 | *_h.h 77 | *.ilk 78 | *.meta 79 | *.obj 80 | *.iobj 81 | *.pch 82 | *.pdb 83 | *.ipdb 84 | *.pgc 85 | *.pgd 86 | *.rsp 87 | *.sbr 88 | *.tlb 89 | *.tli 90 | *.tlh 91 | *.tmp 92 | *.tmp_proj 93 | *_wpftmp.csproj 94 | *.log 95 | *.vspscc 96 | *.vssscc 97 | .builds 98 | *.pidb 99 | *.svclog 100 | *.scc 101 | 102 | # Chutzpah Test files 103 | _Chutzpah* 104 | 105 | # Visual C++ cache files 106 | ipch/ 107 | *.aps 108 | *.ncb 109 | *.opendb 110 | *.opensdf 111 | *.sdf 112 | *.cachefile 113 | *.VC.db 114 | *.VC.VC.opendb 115 | 116 | # Visual Studio profiler 117 | *.psess 118 | *.vsp 119 | *.vspx 120 | *.sap 121 | 122 | # Visual Studio Trace Files 123 | *.e2e 124 | 125 | # TFS 2012 Local Workspace 126 | $tf/ 127 | 128 | # Guidance Automation Toolkit 129 | *.gpState 130 | 131 | # ReSharper is a .NET coding add-in 132 | _ReSharper*/ 133 | *.[Rr]e[Ss]harper 134 | *.DotSettings.user 135 | 136 | # TeamCity is a build add-in 137 | _TeamCity* 138 | 139 | # DotCover is a Code Coverage Tool 140 | *.dotCover 141 | 142 | # AxoCover is a Code Coverage Tool 143 | .axoCover/* 144 | !.axoCover/settings.json 145 | 146 | # Coverlet is a free, cross platform Code Coverage Tool 147 | coverage*[.json, .xml, .info] 148 | 149 | # Visual Studio code coverage results 150 | *.coverage 151 | *.coveragexml 152 | 153 | # NCrunch 154 | _NCrunch_* 155 | .*crunch*.local.xml 156 | nCrunchTemp_* 157 | 158 | # MightyMoose 159 | *.mm.* 160 | AutoTest.Net/ 161 | 162 | # Web workbench (sass) 163 | .sass-cache/ 164 | 165 | # Installshield output folder 166 | [Ee]xpress/ 167 | 168 | # DocProject is a documentation generator add-in 169 | DocProject/buildhelp/ 170 | DocProject/Help/*.HxT 171 | DocProject/Help/*.HxC 172 | DocProject/Help/*.hhc 173 | DocProject/Help/*.hhk 174 | DocProject/Help/*.hhp 175 | DocProject/Help/Html2 176 | DocProject/Help/html 177 | 178 | # Click-Once directory 179 | publish/ 180 | 181 | # Publish Web Output 182 | *.[Pp]ublish.xml 183 | *.azurePubxml 184 | # Note: Comment the next line if you want to checkin your web deploy settings, 185 | # but database connection strings (with potential passwords) will be unencrypted 186 | *.pubxml 187 | *.publishproj 188 | 189 | # Microsoft Azure Web App publish settings. Comment the next line if you want to 190 | # checkin your Azure Web App publish settings, but sensitive information contained 191 | # in these scripts will be unencrypted 192 | PublishScripts/ 193 | 194 | # NuGet Packages 195 | *.nupkg 196 | # NuGet Symbol Packages 197 | *.snupkg 198 | # The packages folder can be ignored because of Package Restore 199 | **/[Pp]ackages/* 200 | # except build/, which is used as an MSBuild target. 201 | !**/[Pp]ackages/build/ 202 | # Uncomment if necessary however generally it will be regenerated when needed 203 | #!**/[Pp]ackages/repositories.config 204 | # NuGet v3's project.json files produces more ignorable files 205 | *.nuget.props 206 | *.nuget.targets 207 | 208 | # Microsoft Azure Build Output 209 | csx/ 210 | *.build.csdef 211 | 212 | # Microsoft Azure Emulator 213 | ecf/ 214 | rcf/ 215 | 216 | # Windows Store app package directories and files 217 | AppPackages/ 218 | BundleArtifacts/ 219 | Package.StoreAssociation.xml 220 | _pkginfo.txt 221 | *.appx 222 | *.appxbundle 223 | *.appxupload 224 | 225 | # Visual Studio cache files 226 | # files ending in .cache can be ignored 227 | *.[Cc]ache 228 | # but keep track of directories ending in .cache 229 | !?*.[Cc]ache/ 230 | 231 | # Others 232 | ClientBin/ 233 | ~$* 234 | *~ 235 | *.dbmdl 236 | *.dbproj.schemaview 237 | *.jfm 238 | *.pfx 239 | *.publishsettings 240 | orleans.codegen.cs 241 | 242 | # Including strong name files can present a security risk 243 | # (https://github.com/github/gitignore/pull/2483#issue-259490424) 244 | #*.snk 245 | 246 | # Since there are multiple workflows, uncomment next line to ignore bower_components 247 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) 248 | #bower_components/ 249 | 250 | # RIA/Silverlight projects 251 | Generated_Code/ 252 | 253 | # Backup & report files from converting an old project file 254 | # to a newer Visual Studio version. Backup files are not needed, 255 | # because we have git ;-) 256 | _UpgradeReport_Files/ 257 | Backup*/ 258 | UpgradeLog*.XML 259 | UpgradeLog*.htm 260 | ServiceFabricBackup/ 261 | *.rptproj.bak 262 | 263 | # SQL Server files 264 | *.mdf 265 | *.ldf 266 | *.ndf 267 | 268 | # Business Intelligence projects 269 | *.rdl.data 270 | *.bim.layout 271 | *.bim_*.settings 272 | *.rptproj.rsuser 273 | *- [Bb]ackup.rdl 274 | *- [Bb]ackup ([0-9]).rdl 275 | *- [Bb]ackup ([0-9][0-9]).rdl 276 | 277 | # Microsoft Fakes 278 | FakesAssemblies/ 279 | 280 | # GhostDoc plugin setting file 281 | *.GhostDoc.xml 282 | 283 | # Node.js Tools for Visual Studio 284 | .ntvs_analysis.dat 285 | node_modules/ 286 | 287 | # Visual Studio 6 build log 288 | *.plg 289 | 290 | # Visual Studio 6 workspace options file 291 | *.opt 292 | 293 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.) 294 | *.vbw 295 | 296 | # Visual Studio LightSwitch build output 297 | **/*.HTMLClient/GeneratedArtifacts 298 | **/*.DesktopClient/GeneratedArtifacts 299 | **/*.DesktopClient/ModelManifest.xml 300 | **/*.Server/GeneratedArtifacts 301 | **/*.Server/ModelManifest.xml 302 | _Pvt_Extensions 303 | 304 | # Paket dependency manager 305 | .paket/paket.exe 306 | paket-files/ 307 | 308 | # FAKE - F# Make 309 | .fake/ 310 | 311 | # CodeRush personal settings 312 | .cr/personal 313 | 314 | # Python Tools for Visual Studio (PTVS) 315 | __pycache__/ 316 | *.pyc 317 | 318 | # Cake - Uncomment if you are using it 319 | # tools/** 320 | # !tools/packages.config 321 | 322 | # Tabs Studio 323 | *.tss 324 | 325 | # Telerik's JustMock configuration file 326 | *.jmconfig 327 | 328 | # BizTalk build output 329 | *.btp.cs 330 | *.btm.cs 331 | *.odx.cs 332 | *.xsd.cs 333 | 334 | # OpenCover UI analysis results 335 | OpenCover/ 336 | 337 | # Azure Stream Analytics local run output 338 | ASALocalRun/ 339 | 340 | # MSBuild Binary and Structured Log 341 | *.binlog 342 | 343 | # NVidia Nsight GPU debugger configuration file 344 | *.nvuser 345 | 346 | # MFractors (Xamarin productivity tool) working folder 347 | .mfractor/ 348 | 349 | # Local History for Visual Studio 350 | .localhistory/ 351 | 352 | # BeatPulse healthcheck temp database 353 | healthchecksdb 354 | 355 | # Backup folder for Package Reference Convert tool in Visual Studio 2017 356 | MigrationBackup/ 357 | 358 | # Ionide (cross platform F# VS Code tools) working folder 359 | .ionide/ 360 | 361 | # Fody - auto-generated XML schema 362 | FodyWeavers.xsd 363 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 |

2 | 3 |

4 | 5 | # Fondamenti di Informatica II e Lab - UNIMORE 6 | [![License](https://img.shields.io/github/license/prittt/fondamenti-ii)](https://github.com/prittt/fondamenti-ii/blob/master/LICENSE) 7 | [![Docs](https://readthedocs.org/projects/pip/badge/?version=latest&style=flat)](https://github.com/prittt/fondamenti-ii/blob/master/README.md#doc) 8 | [![Build Status](https://travis-ci.com/prittt/fondamenti-ii.svg?token=uFxAjG3MrtqGf83nu4qz&branch=master)](https://travis-ci.com/prittt/fondamenti-ii) 9 | 10 |

11 | Questo repository è principalmente rivolto agli studenti di Fondamenti di Informatica II e Lab del Corso di Laurea Triennale in Ingegneria Informatica del Dipartimento di Ingegneria "Enzo Ferrari" dell'Università degli Studi di Modena e Reggio Emilia. Il repository contiene le primitive di liste, alberi e heap viste a lezione ed usate per le esercitazioni. 12 |

13 | 14 |

15 | La struttura del progetto è la seguente: 16 |

17 | 18 | ``` 19 | . 20 | ├── elemtype 21 | | ├── int 22 | | | ├── elemtype.h 23 | | | ├── elemtype.c 24 | | ├── char 25 | | | ├── elemtype.h 26 | | | ├── elemtype.c 27 | | ├── int_vector 28 | | | ├── elemtype.h 29 | | | ├── elemtype.c 30 | | ├── ... 31 | ├── list 32 | | ├── int 33 | | | ├── examples 34 | | | | ├── ins_ord.c 35 | | | | ├── iterate.c 36 | | ├── int_vector 37 | | | ├── examples 38 | | | | ├── iterate.c 39 | | ├── list.h 40 | | ├── list.c 41 | ├── tree 42 | ├── minheap 43 | ├── ... 44 | 45 | ``` 46 | 47 |

48 | Come potete notare, il codice relativo ad una specifica struttura dati si trova in una sottocartella con lo stesso nome: list, tree, minheap. Per ognuna di queste viene fornita un'unica implementazione generica che non dipende dal tipo di dato. Le dichiarazioni e le definizioni di ElemType per uno specifico tipo di dato le trovate in sottocartelle di elemtype, rispettivamente nei file .h e .c. Le implementazioni di liste, alberi, e heap devono essere accompagnate da un'implementazione specifica di ElemType per funzionare correttamente. 49 |

50 | 51 |

52 | Ad esempio, nella cartella list troviamo i file list.h e list.c che forniscono l'implementazione delle liste e che dovranno essere accompagnati dalla definizione di ElemType e dall'implementazione delle funzioni a esso associate. Se vogliamo utilizzizare liste di int, ad esempio, avremo bisogno anche dei file elemtype>int>elemtype.h e elemtype>int>elemtype.c. 53 |

54 | 55 |

56 | Nelle sottocartelle examples sono disponibili dei file .c contenenti delle funzioni di esempio di utilizzo delle primitive. 57 |

58 | 59 |

60 | Il restante materiale è utilizzato per la gestione del repository: generazione automatica della documentazione, generazione del progetto, ecc e può essere pertanto ignorato. Nel seguito di questa pagina troverete i link alla documentazione delle primitive e i link per il download diretto di primitive specifiche, ovvero primitive accompagnate ad una specifica implementazione di ElemType. 61 |

62 | 63 |

Funzioni Primitive e Documentazione

64 | 65 |

66 | In questa sezione vengono forniti i link per il download diretto delle funzioni primitive di diverse strutture dati, eventualmente accompagnate dai file che definiscono e implementano l'ElemType per uno specifico tipo di dato. Vengono inoltre forniti i link alle pagine web contenenti la documentazione. 67 |

68 | 69 | ### Liste (Singly Linked List) 70 | 71 | | Tipo di Dato | Documentazione | Sorgente | 72 | |:------------:|:--------------:|:------------------:| 73 | | no elemtype
(solo liste) | list.html | list.zip | 74 | | `int` | list_int.html | list_int.zip | 75 | | `char` | list_char.html | list_char.zip | 76 | | `int-vector` | list_int_vector.html | list_int_vector.zip | 77 | | `point2d` | list_point2d.html | list_point2d.zip | 78 | 79 | ### Liste (Doubly Linked List) 80 | 81 | | Tipo di Dato | Documentazione | Sorgente | 82 | |:------------:|:--------------:|:------------------:| 83 | | no elemtype
(solo liste) | doublelist.html | doublelist.zip | 84 | | `int` | doublelist_int.html | doublelist_int.zip | 85 | 86 | ### Alberi (Binary Tree) 87 | 88 | | Tipo di Dato | Documentazione | Sorgente | 89 | |:------------:|:--------------:|:------------------:| 90 | | no elemtype
(solo alberi) | tree.html | tree.zip | 91 | | `int` | tree_int.html | tree_int.zip | 92 | | `char` | tree_char.html | tree_char.zip | 93 | 94 | ### Min-Heap (Array-Based Binary Min-Heap) 95 | 96 | | Tipo di Dato | Documentazione | Sorgente | 97 | |:------------:|:--------------:|:------------------:| 98 | | no elemtype
(solo heap) | minheap.html | minheap.zip | 99 | | `int` | minheap_int.html | minheap_int.zip | 100 | 101 | 102 | ### ElemType Only 103 | 104 | | Tipo di Dato | Documentazione | Sorgente | 105 | |:------------:|:--------------:|:------------------:| 106 | | `int` | elemtype_int.html | elemtype_int.zip | 107 | | `char` | elemtype_char.html | elemtype_char.zip | 108 | | `int-vector` | elemtype_int_vector.html | elemtype_int_vector.zip | 109 | | `point2D` | elemtype_point2d.html | elemtype_point2d.zip | 110 | 111 | -------------------------------------------------------------------------------- /doc/utils/DoxygenLayout.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 | 226 | 227 | 228 | -------------------------------------------------------------------------------- /doc/utils/DoxygenLayoutNoHome.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 | 226 | 227 | 228 | -------------------------------------------------------------------------------- /tree/tree.h: -------------------------------------------------------------------------------- 1 | /** @file 2 | Questo file contiene la definizione del tipo `Node` e la documentazione delle 3 | funzioni primitive (e non) relative agli alberi binari. Si noti che il 4 | comportamento di queste funzioni è indipendente dalla definizione di `ElemType`. 5 | */ 6 | 7 | #ifndef TREE_H_ 8 | #define TREE_H_ 9 | 10 | #include "elemtype.h" 11 | 12 | #include 13 | #include 14 | 15 | /*****************************************************************************/ 16 | /* Node & Primitives */ 17 | /*****************************************************************************/ 18 | 19 | /** @brief Definizione del tipo `struct Node`. */ 20 | struct Node { 21 | ElemType value; /*!< Valore associato al `Node`. */ 22 | struct Node *left; /*!< Puntatore al figlio sinistro. */ 23 | struct Node *right; /*!< Puntatore al figlio destro. */ 24 | }; 25 | /** @brief Definizione di un nome alternativo per `struct Node`. */ 26 | typedef struct Node Node; 27 | 28 | /** @brief La funzione `TreeCreateEmpty()` crea e ritorna un albero vuoto, 29 | ovvero `NULL`. 30 | 31 | @return Albero vuoto (`NULL`). 32 | */ 33 | Node* TreeCreateEmpty(void); 34 | 35 | /** @brief La funzione `TreeCreateRoot()` crea un nuovo albero avente come radice 36 | il valore specificato e come figli sinistro e destro i sottoalberi 37 | specificati. La funzione ritorna quindi il puntatore al nodo radice 38 | dell'albero appena creato. 39 | 40 | @param[in] e Puntatore all'elemento il cui valore sarà copiato nel nodo radice del 41 | nuovo albero. 42 | @param[in] l Figlio sinistro del nuovo albero. Il valore contenuto in `l` non 43 | viene modificato dalla funzion. `l` può anche essere un albero 44 | vuoto (`NULL`). 45 | @param[in] r Figlio destro del nuovo albero. Il valore contenuto in `r` non viene 46 | modificato dalla funzione. `r` anche essere un albero vuoto (`NULL`). 47 | 48 | @return Puntatore al nodo radice dell'albero appena creato. 49 | */ 50 | Node* TreeCreateRoot(const ElemType *e, Node* l, Node* r); 51 | 52 | /** @brief La funzione `TreeIsEmpty()` verifica se un albero è vuoto o meno. 53 | 54 | @param[in] n Albero su cui eseguire il test. 55 | 56 | @return `true` se l'albero è vuoto, `false` altrimenti. 57 | */ 58 | bool TreeIsEmpty(const Node *n); 59 | 60 | /** @brief La funzione `TreeGetRootValue()` ritorna un puntatore all'elemento 61 | contentuto nel nodo radice dell'albero specificato. 62 | 63 | @param[in] n Albero da cui estratte il valore. L'albero NON può essere vuoto, 64 | nel caso in cui lo sia la funzione termina il programma con codice di 65 | errore `1`. 66 | 67 | @returns Puntatore all'elemento (costante) contenuto nel nodo radice dell'albero. 68 | */ 69 | const ElemType *TreeGetRootValue(const Node *n); 70 | 71 | /** @brief La funzione `TreeLeft()` ritorna un puntatore al nodo figlio sinistro 72 | dell'albero specificato. 73 | 74 | @param[in] n Albero da cui ottenere il figlio sinistro che può eventualmente essere 75 | vuoto (`NULL`). Il nodo `n` non viene modificato. 76 | 77 | @returns Puntatore al nodo figlio sinistro dell'albero specificato. Se l'albero 78 | specificato è vuoto o non ha un figlio sinistro la funzione ritorna 79 | un albero vuoto (`NULL`). 80 | */ 81 | Node *TreeLeft(const Node *n); 82 | 83 | /** @brief La funzione `TreeRight()` ritorna un puntatore al nodo figlio destro 84 | dell'albero specificato. 85 | 86 | @param[in] n Albero da cui ottenere il figlio destro che può eventualmente essere 87 | vuoto (`NULL`). Il nodo `n` non viene modificato. 88 | 89 | @returns Puntatore al nodo figlio destro dell'albero specificato. Se l'albero 90 | specificato è vuoto o non ha un figlio destro la funzione ritorna 91 | un albero vuoto (`NULL`). 92 | */ 93 | Node *TreeRight(const Node *n); 94 | 95 | /** @brief La funzione `TreeIsLeaf()` verifica se il nodo specificato è una foglia. 96 | 97 | @param[in] n Puntatore al nodo/albero da verificareche può eventualmente essere 98 | vuoto (`NULL`). Il nodo `n` non viene modificato. 99 | 100 | @returns `true` se il nodo è una foglia, ovvero se è un nodo vuoto (`NULL`) 101 | o se entrambi i suoi figli (sinistro e destro) sono nodi vuoti (`NULL`), 102 | `false` altrimenti. 103 | */ 104 | bool TreeIsLeaf(const Node *n); 105 | 106 | /** @brief La funzione `TreeDelete()` libera la memoria occupata dai nodi di un 107 | albero. 108 | 109 | @param[in] n Albero di cui liberare la memoria. Può essere un albero vuoto (`NULL`). 110 | 111 | @return Non ci sono valori di ritorno. 112 | */ 113 | void TreeDelete(Node *n); 114 | 115 | /*****************************************************************************/ 116 | /* Non Primitives */ 117 | /*****************************************************************************/ 118 | 119 | /** @brief La funzione `TreeWritePreOrder()` stampa l'albero specificato su file, 120 | visitandolo in pre-ordine. Nello specifico, la funzione stampa la 121 | sequenza di caratteri "Albero in PreOrdine: " seguita dagli elementi 122 | in ordine di visita e separati dal carattere . La stampa degli 123 | elementi dipende dalla definizione di `ElemType`. Se l'albero è 124 | vuoto i caratteri sopra elencati saranno seguiti da "vuoto!". 125 | 126 | @param[in] n Albero da stampare su file. L'albero non viene modificato e può 127 | essere vuoto. 128 | @param[in] f `FILE *` su cui stampare l'albero. 129 | 130 | @return Non ci sono valori di ritorno. 131 | */ 132 | void TreeWritePreOrder(const Node *n, FILE *f); 133 | 134 | /** @brief La funzione `TreeWriteStdoutPreOrder()` stampa l'albero specificato su 135 | `stdout`, visitandolo in pre-ordine. Nello specifico, la funzione stampa la 136 | sequenza di caratteri "Albero in PreOrdine: " seguita dagli elementi 137 | in ordine di visita e separati dal carattere . La stampa degli 138 | elementi dipende dalla definizione di `ElemType`. Se l'albero è vuoto 139 | i caratteri sopra elencati saranno seguiti da "vuoto!". 140 | 141 | @param[in] n Albero da stampare su `stdout`. L'albero non viene modificato e 142 | può essere vuoto. 143 | 144 | @return Non ci sono valori di ritorno. 145 | */ 146 | void TreeWriteStdoutPreOrder(const Node *n); 147 | 148 | /** @brief La funzione `TreeWriteInOrder()` stampa l'albero specificato su file, 149 | visitandolo in ordine. Nello specifico, la funzione stampa la 150 | sequenza di caratteri "Albero in Ordine: " seguita dagli elementi 151 | in ordine di visita e separati dal carattere . La stampa degli 152 | elementi dipende dalla definizione di `ElemType`. Se l'albero è vuoto 153 | i caratteri sopra elencati saranno seguiti da "vuoto!". 154 | 155 | @param[in] n Albero da stampare su file. L'albero non viene modificato e può 156 | essere vuoto. 157 | @param[in] f `FILE *` su cui stampare l'albero. 158 | 159 | @return Non ci sono valori di ritorno. 160 | */ 161 | void TreeWriteInOrder(const Node *n, FILE *f); 162 | 163 | /** @brief La funzione `TreeWriteStdoutInOrder()` stampa l'albero specificato su 164 | `stdout`, visitandolo in ordine. Nello specifico, la funzione stampa la 165 | sequenza di caratteri "Albero in Ordine: " seguita dagli elementi 166 | in ordine di visita e separati dal carattere . La stampa degli 167 | elementi dipende dalla definizione di `ElemType`. Se l'albero è vuoto 168 | i caratteri sopra elencati saranno seguiti da "vuoto!". 169 | 170 | @param[in] n Albero da stampare su `stdout`. L'albero non viene modificato e può 171 | essere vuoto. 172 | 173 | @return Non ci sono valori di ritorno. 174 | */ 175 | void TreeWriteStdoutInOrder(const Node *n); 176 | 177 | /** @brief La funzione `TreeWritePostOrder()` stampa l'albero specificato su file, 178 | visitandolo in post-ordine. Nello specifico, la funzione stampa la 179 | sequenza di caratteri "Albero in PostOrdine: " seguita dagli elementi 180 | in ordine di visita e separati dal carattere . La stampa degli 181 | elementi dipende dalla definizione di `ElemType`. Se l'albero è vuoto 182 | i caratteri sopra elencati saranno seguiti da "vuoto!". 183 | 184 | @param[in] n Albero da stampare su file. L'albero non viene modificato e può 185 | essere vuoto. 186 | @param[in] f `FILE *` su cui stampare l'albero. 187 | 188 | @return Non ci sono valori di ritorno. 189 | */ 190 | void TreeWritePostOrder(const Node *n, FILE *f); 191 | 192 | /** @brief La funzione `TreeWriteStdoutPostOrder()` stampa l'albero specificato su 193 | `stdout`, visitandolo in post-ordine. Nello specifico, la funzione stampa la 194 | sequenza di caratteri "Albero in PostOrdine: " seguita dagli elementi 195 | in ordine di visita e separati dal carattere . La stampa degli 196 | elementi dipende dalla definizione di `ElemType`. Se l'albero è vuoto 197 | i caratteri sopra elencati saranno seguiti da "vuoto!". 198 | 199 | @param[in] n Albero da stampare su `stdout`. L'albero non viene modificato e può 200 | essere vuoto. 201 | 202 | @return Non ci sono valori di ritorno. 203 | */ 204 | void TreeWriteStdoutPostOrder(const Node *n); 205 | 206 | #endif // TREE_H_ 207 | 208 | --------------------------------------------------------------------------------