├── Name.txt ├── LibraryCPPTemplate ├── CMakeLists.txt ├── hash.h ├── array.h ├── graph.h ├── vector.h ├── Tests │ ├── array.cpp │ ├── CMakeLists.txt │ ├── hash.cpp │ ├── list.cpp │ ├── stack.cpp │ ├── queue.cpp │ ├── graph.cpp │ └── vector.cpp ├── stack.h ├── queue.h └── list.h ├── Practice ├── make.sh ├── make.bat ├── .gitignore ├── sources │ ├── array1.cpp │ ├── list1.cpp │ ├── array2.cpp │ ├── vector1.cpp │ └── map1.cpp ├── title.tex ├── titleback.tex ├── preamble.tex └── book.tex ├── containers.png ├── LibraryCPP ├── array.cpp ├── queue.cpp ├── binaryHeap.cpp ├── huffmanTree.h ├── huffmanCode.cpp ├── huffmanTree.cpp ├── Tests │ ├── binaryHeap.cpp │ ├── huffmanTree.cpp │ ├── priorityQueue.cpp │ ├── array.cpp │ ├── list.cpp │ ├── queue.cpp │ ├── stack.cpp │ ├── CMakeLists.txt │ └── vector.cpp ├── CMakeLists.txt ├── huffmanCode.h ├── priorityQueue.h ├── array.h ├── stack.h ├── queue.h ├── binaryHeap.h ├── vector.h ├── stack.cpp ├── priorityQueue.cpp ├── list.h ├── vector.cpp └── list.cpp ├── LibraryC ├── CMakeLists.txt ├── stack.c ├── queue.c ├── vector.c ├── array.c ├── Tests │ ├── array.cpp │ ├── CMakeLists.txt │ ├── list.cpp │ ├── queue.cpp │ ├── stack.cpp │ └── vector.cpp ├── array.h ├── stack.h ├── queue.h ├── list.c ├── vector.h └── list.h ├── LibraryCPPClass ├── CMakeLists.txt ├── array.cpp ├── vector.cpp ├── stack.cpp ├── queue.cpp ├── Tests │ ├── array.cpp │ ├── list.cpp │ ├── stack.cpp │ ├── queue.cpp │ ├── CMakeLists.txt │ └── vector.cpp ├── list.cpp ├── array.h ├── stack.h ├── queue.h ├── vector.h └── list.h ├── .gitignore ├── Labs ├── lab6.cpp ├── CMakeLists.txt ├── lab1.cpp ├── lab5.cpp ├── lab2.cpp ├── lab3.cpp └── lab4.cpp ├── CMakeLists.txt ├── .github └── workflows │ ├── cppcheck.yml │ ├── clangtidy.yml │ └── cmake.yml ├── LABS.md └── README.md /Name.txt: -------------------------------------------------------------------------------- 1 | Антонов Сергей Сергеевич, гр.2091 -------------------------------------------------------------------------------- /LibraryCPPTemplate/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(Tests) 2 | -------------------------------------------------------------------------------- /Practice/make.sh: -------------------------------------------------------------------------------- 1 | pdflatex book.tex 2 | pdflatex book.tex 3 | rm *.aux 4 | rm *.toc -------------------------------------------------------------------------------- /Practice/make.bat: -------------------------------------------------------------------------------- 1 | pdflatex book.tex 2 | pdflatex book.tex 3 | del *.aux 4 | del *.toc -------------------------------------------------------------------------------- /containers.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/containers.png -------------------------------------------------------------------------------- /LibraryCPP/array.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/LibraryCPP/array.cpp -------------------------------------------------------------------------------- /LibraryCPP/queue.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/LibraryCPP/queue.cpp -------------------------------------------------------------------------------- /LibraryCPP/binaryHeap.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/LibraryCPP/binaryHeap.cpp -------------------------------------------------------------------------------- /LibraryCPP/huffmanTree.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/LibraryCPP/huffmanTree.h -------------------------------------------------------------------------------- /LibraryCPPTemplate/hash.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/LibraryCPPTemplate/hash.h -------------------------------------------------------------------------------- /LibraryCPP/huffmanCode.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/LibraryCPP/huffmanCode.cpp -------------------------------------------------------------------------------- /LibraryCPP/huffmanTree.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/LibraryCPP/huffmanTree.cpp -------------------------------------------------------------------------------- /LibraryCPPTemplate/array.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/LibraryCPPTemplate/array.h -------------------------------------------------------------------------------- /LibraryCPPTemplate/graph.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/LibraryCPPTemplate/graph.h -------------------------------------------------------------------------------- /LibraryCPPTemplate/vector.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/LibraryCPPTemplate/vector.h -------------------------------------------------------------------------------- /LibraryCPP/Tests/binaryHeap.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/LibraryCPP/Tests/binaryHeap.cpp -------------------------------------------------------------------------------- /LibraryCPP/Tests/huffmanTree.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/LibraryCPP/Tests/huffmanTree.cpp -------------------------------------------------------------------------------- /Practice/.gitignore: -------------------------------------------------------------------------------- 1 | *.aux 2 | *.log 3 | *.pdf 4 | *.toc 5 | *.bak 6 | *.nav 7 | *.vrb 8 | *.snm 9 | *.out 10 | -------------------------------------------------------------------------------- /LibraryCPP/Tests/priorityQueue.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Sergeo-Sss/Algorithms/HEAD/LibraryCPP/Tests/priorityQueue.cpp -------------------------------------------------------------------------------- /LibraryC/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library(LibraryC STATIC array.c list.c queue.c stack.c vector.c) 2 | 3 | add_subdirectory(Tests) 4 | -------------------------------------------------------------------------------- /LibraryCPPClass/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library(LibraryCPPClass STATIC array.cpp list.cpp queue.cpp stack.cpp vector.cpp) 2 | 3 | add_subdirectory(Tests) 4 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.opensdf 2 | *.sdf 3 | *.suo 4 | *.user 5 | *.filters 6 | *.obj 7 | *.exe 8 | ipch/* 9 | */Debug/* 10 | */Release/* 11 | Debug/* 12 | Release/* 13 | .vs/* 14 | build/* 15 | out/* -------------------------------------------------------------------------------- /LibraryCPP/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library(LibraryCPP STATIC array.cpp list.cpp stack.cpp vector.cpp queue.cpp huffmanTree.cpp binaryHeap.cpp priorityQueue.cpp huffmanCode.cpp) 2 | 3 | add_subdirectory(Tests) 4 | -------------------------------------------------------------------------------- /LibraryCPP/huffmanCode.h: -------------------------------------------------------------------------------- 1 | #ifndef HUFFMANCODE_H 2 | #define HUFFMANCODE_H 3 | 4 | #include 5 | 6 | void huffman_compress(std::ifstream& fileIn, const std::string& compressedFileName); 7 | 8 | void huffman_decompress(std::ifstream& fileIn, const std::string& decompressedFileName); 9 | 10 | #endif -------------------------------------------------------------------------------- /Labs/lab6.cpp: -------------------------------------------------------------------------------- 1 | #include "huffmanCode.h" 2 | 3 | int main() 4 | { 5 | std::ifstream fileIn; 6 | fileIn.open("testText.txt", std::ios::binary); 7 | huffman_compress(fileIn, "compressedText.arc"); 8 | fileIn.close(); 9 | fileIn.open("compressedText.arc", std::ios::binary); 10 | huffman_decompress(fileIn, "decompessedText.txt"); 11 | fileIn.close(); 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.15) 2 | project(Algorithms) 3 | 4 | enable_testing() 5 | set(CMAKE_COMPILE_WARNING_AS_ERROR ON) 6 | if (MSVC) 7 | # needs at least cmake 3.15 8 | add_compile_options(/W4 /WX) 9 | else() 10 | add_compile_options(-Wall -Wextra -Wpedantic -Wno-gnu-empty-struct -Wno-unused-parameter) 11 | endif() 12 | 13 | add_subdirectory(LibraryCPP) 14 | add_subdirectory(LibraryCPPTemplate) 15 | 16 | add_subdirectory(Labs) -------------------------------------------------------------------------------- /Practice/sources/array1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | typedef int MyArr[5]; 4 | 5 | void f(MyArr a) 6 | { 7 | a[4] = 0; 8 | } 9 | 10 | int sum(MyArr a) 11 | { 12 | int r = 0; 13 | for (int i = 0 ; i < 5 ; ++i) 14 | r += a[i]; 15 | 16 | return r; 17 | } 18 | 19 | int main() 20 | { 21 | MyArr a = {1, 2, 3, 4, 5}; 22 | std::cout << "Sum1: " << sum(a) << '\n'; 23 | f(a); 24 | std::cout << "Sum2: " << sum(a) << '\n'; 25 | } 26 | -------------------------------------------------------------------------------- /Practice/sources/list1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int n; 6 | std::cin >> n; 7 | int *a = new int[n]; 8 | for (int i = 0 ; i < n ; ++i) 9 | { 10 | int v; 11 | std::cin >> v; 12 | for (int j = i ; j > 0 ; --j) 13 | a[j] = a[j - 1]; 14 | a[0] = v; 15 | } 16 | 17 | for (int i = 0 ; i < n ; ++i) 18 | std::cout << a[i] << ' '; 19 | std::cout << '\n'; 20 | delete[] a; 21 | } 22 | -------------------------------------------------------------------------------- /Practice/sources/array2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef std::array MyArr; 5 | 6 | void f(MyArr a) 7 | { 8 | a[4] = 0; 9 | } 10 | 11 | int sum(MyArr a) 12 | { 13 | int r = 0; 14 | for (int i = 0 ; i < 5 ; ++i) 15 | r += a[i]; 16 | 17 | return r; 18 | } 19 | 20 | int main() 21 | { 22 | MyArr a = {1, 2, 3, 4, 5}; 23 | std::cout << "Sum1: " << sum(a) << '\n'; 24 | f(a); 25 | std::cout << "Sum2: " << sum(a) << '\n'; 26 | } 27 | -------------------------------------------------------------------------------- /LibraryCPPClass/array.cpp: -------------------------------------------------------------------------------- 1 | #include "array.h" 2 | 3 | Array::Array(size_t size) 4 | { 5 | } 6 | 7 | Array::Array(const Array &a) 8 | { 9 | } 10 | 11 | Array &Array::operator=(const Array &a) 12 | { 13 | return *this; 14 | } 15 | 16 | Array::~Array() 17 | { 18 | } 19 | 20 | Data Array::get(size_t index) const 21 | { 22 | return Data(0); 23 | } 24 | 25 | void Array::set(size_t index, Data value) 26 | { 27 | } 28 | 29 | size_t Array::size() const 30 | { 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /LibraryCPPClass/vector.cpp: -------------------------------------------------------------------------------- 1 | #include "vector.h" 2 | 3 | Vector::Vector() 4 | { 5 | } 6 | 7 | Vector::Vector(const Vector &a) 8 | { 9 | } 10 | 11 | Vector &Vector::operator=(const Vector &a) 12 | { 13 | return *this; 14 | } 15 | 16 | Vector::~Vector() 17 | { 18 | } 19 | 20 | Data Vector::get(size_t index) const 21 | { 22 | return Data(); 23 | } 24 | 25 | void Vector::set(size_t index, Data value) 26 | { 27 | } 28 | 29 | size_t Vector::size() const 30 | { 31 | return 0; 32 | } 33 | 34 | void Vector::resize(size_t size) 35 | { 36 | } 37 | -------------------------------------------------------------------------------- /LibraryCPPClass/stack.cpp: -------------------------------------------------------------------------------- 1 | #include "stack.h" 2 | 3 | Stack::Stack() 4 | { 5 | } 6 | 7 | Stack::Stack(const Stack &a) 8 | { 9 | // implement or disable this function 10 | } 11 | 12 | Stack &Stack::operator=(const Stack &a) 13 | { 14 | // implement or disable this function 15 | return *this; 16 | } 17 | 18 | Stack::~Stack() 19 | { 20 | } 21 | 22 | void Stack::push(Data data) 23 | { 24 | } 25 | 26 | Data Stack::get() const 27 | { 28 | return Data(); 29 | } 30 | 31 | void Stack::pop() 32 | { 33 | } 34 | 35 | bool Stack::empty() const 36 | { 37 | return true; 38 | } 39 | -------------------------------------------------------------------------------- /LibraryC/stack.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "stack.h" 3 | 4 | typedef struct Stack 5 | { 6 | } Stack; 7 | 8 | Stack *stack_create(FFree f) 9 | { 10 | return malloc(sizeof(Stack)); 11 | } 12 | 13 | void stack_delete(Stack *stack) 14 | { 15 | // TODO: free stack elements 16 | free(stack); 17 | } 18 | 19 | void stack_push(Stack *stack, Data data) 20 | { 21 | } 22 | 23 | Data stack_get(const Stack *stack) 24 | { 25 | return (Data)0; 26 | } 27 | 28 | void stack_pop(Stack *stack) 29 | { 30 | } 31 | 32 | bool stack_empty(const Stack *stack) 33 | { 34 | return true; 35 | } 36 | -------------------------------------------------------------------------------- /LibraryCPPClass/queue.cpp: -------------------------------------------------------------------------------- 1 | #include "queue.h" 2 | 3 | Queue::Queue() 4 | { 5 | } 6 | 7 | Queue::Queue(const Queue &a) 8 | { 9 | // implement or disable this function 10 | } 11 | 12 | Queue &Queue::operator=(const Queue &a) 13 | { 14 | // implement or disable this function 15 | return *this; 16 | } 17 | 18 | Queue::~Queue() 19 | { 20 | } 21 | 22 | void Queue::insert(Data data) 23 | { 24 | } 25 | 26 | Data Queue::get() const 27 | { 28 | return Data(); 29 | } 30 | 31 | void Queue::remove() 32 | { 33 | } 34 | 35 | bool Queue::empty() const 36 | { 37 | return true; 38 | } 39 | -------------------------------------------------------------------------------- /LibraryC/queue.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "queue.h" 3 | 4 | typedef struct Queue 5 | { 6 | } Queue; 7 | 8 | Queue *queue_create(FFree f) 9 | { 10 | return malloc(sizeof(Queue)); 11 | } 12 | 13 | void queue_delete(Queue *queue) 14 | { 15 | // TODO: free queue items 16 | free(queue); 17 | } 18 | 19 | void queue_insert(Queue *queue, Data data) 20 | { 21 | } 22 | 23 | Data queue_get(const Queue *queue) 24 | { 25 | return (Data)0; 26 | } 27 | 28 | void queue_remove(Queue *queue) 29 | { 30 | } 31 | 32 | bool queue_empty(const Queue *queue) 33 | { 34 | return true; 35 | } 36 | -------------------------------------------------------------------------------- /LibraryCPP/priorityQueue.h: -------------------------------------------------------------------------------- 1 | #ifndef PRIORITYQUEUE_H 2 | #define PRIORITYQUEUE_H 3 | 4 | #include "binaryHeap.h" 5 | 6 | struct PriorityQueue; 7 | 8 | PriorityQueue* priorityQueue_create(const size_t size, Comparator comp, Destructor dest); 9 | 10 | void priorityQueue_delete(PriorityQueue* queue); 11 | 12 | void priorityQueue_insert(PriorityQueue* queue, void* data); 13 | 14 | void* priorityQueue_getMin(PriorityQueue* queue); 15 | 16 | void* priorityQueue_extractMin(PriorityQueue* queue); 17 | 18 | size_t priorityQueue_getSize(PriorityQueue* queue); 19 | 20 | bool priorityQueue_empty(PriorityQueue* queue); 21 | 22 | #endif -------------------------------------------------------------------------------- /.github/workflows/cppcheck.yml: -------------------------------------------------------------------------------- 1 | name: cppcheck-action-test 2 | on: 3 | push: 4 | branches: [ master ] 5 | pull_request: 6 | branches: [ master ] 7 | 8 | jobs: 9 | build: 10 | name: cppcheck-test 11 | runs-on: ubuntu-latest 12 | steps: 13 | - uses: actions/checkout@v2 14 | 15 | - name: cppcheck 16 | uses: deep5050/cppcheck-action@main 17 | with: 18 | github_token: ${{ secrets.GITHUB_TOKEN}} 19 | output_file: cppcheck.txt 20 | other_options: "--error-exitcode=1" 21 | 22 | - name: print-result 23 | if: always() 24 | run: cat cppcheck.txt 25 | -------------------------------------------------------------------------------- /Practice/sources/vector1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int n; 6 | std::cin >> n; 7 | int *a = new int[n]; 8 | for (int i = 0 ; i < n ; ++i) 9 | std::cin >> a[i]; 10 | 11 | int k; 12 | std::cin >> k; 13 | int m = 0; 14 | for (int i = 0 ; i < n ; ++i) 15 | if (a[i] < k) 16 | ++m; 17 | 18 | int *b = new int[m]; 19 | m = 0; 20 | for (int i = 0 ; i < n ; ++i) 21 | if (a[i] < k) 22 | b[m++] = a[i]; 23 | 24 | delete[] a; 25 | for (int i = 0 ; i < m ; ++i) 26 | std::cout << b[i] << ' '; 27 | delete[] b; 28 | } 29 | -------------------------------------------------------------------------------- /LibraryCPP/array.h: -------------------------------------------------------------------------------- 1 | #ifndef ARRAY_H 2 | #define ARRAY_H 3 | 4 | #include 5 | 6 | // Non-resizeable array 7 | // Stores integer values inside 8 | typedef int Data; 9 | 10 | struct Array; 11 | 12 | // create array 13 | Array *array_create(size_t size); 14 | 15 | // delete array, free memory 16 | void array_delete(Array *arr); 17 | 18 | // returns specified array element 19 | Data array_get(const Array *arr, size_t index); 20 | 21 | // sets the specified array element to the value 22 | void array_set(Array *arr, size_t index, Data value); 23 | 24 | // returns array size 25 | size_t array_size(const Array *arr); 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /LibraryC/vector.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "vector.h" 3 | 4 | typedef struct Vector 5 | { 6 | } Vector; 7 | 8 | Vector *vector_create(FFree f) 9 | { 10 | return malloc(sizeof(Vector)); 11 | } 12 | 13 | void vector_delete(Vector *vector) 14 | { 15 | // TODO: free vector internals 16 | free(vector); 17 | } 18 | 19 | Data vector_get(const Vector *vector, size_t index) 20 | { 21 | return (Data)0; 22 | } 23 | 24 | void vector_set(Vector *vector, size_t index, Data value) 25 | { 26 | } 27 | 28 | size_t vector_size(const Vector *vector) 29 | { 30 | return 0; 31 | } 32 | 33 | void vector_resize(Vector *vector, size_t size) 34 | { 35 | } 36 | -------------------------------------------------------------------------------- /LibraryCPPClass/Tests/array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "array.h" 3 | 4 | int main() 5 | { 6 | Array *arr = new Array(10); 7 | 8 | if (arr->size() != 10) 9 | { 10 | std::cout << "Invalid array size\n"; 11 | return 1; 12 | } 13 | 14 | for (int i = 0 ; i < 10 ; ++i) 15 | arr->set(i, i * 2); 16 | 17 | Array copy(*arr); 18 | 19 | for (int i = 0 ; i < 10 ; ++i) 20 | { 21 | if (arr->get(i) != i * 2 22 | || copy.get(i) != i * 2) 23 | { 24 | std::cout << "Invalid array element " << i << "\n"; 25 | return 1; 26 | } 27 | } 28 | 29 | delete arr; 30 | } 31 | -------------------------------------------------------------------------------- /LibraryCPP/Tests/array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "array.h" 3 | 4 | int main() 5 | { 6 | Array *arr = array_create(10); 7 | 8 | if (array_size(arr) != 10) 9 | { 10 | std::cout << "Invalid array size\n"; 11 | array_delete(arr); 12 | return 1; 13 | } 14 | 15 | for (int i = 0 ; i < 10 ; ++i) 16 | array_set(arr, i, i * 2); 17 | 18 | for (int i = 0 ; i < 10 ; ++i) 19 | { 20 | if (array_get(arr, i) != i * 2) 21 | { 22 | std::cout << "Invalid array element " << i << "\n"; 23 | array_delete(arr); 24 | return 1; 25 | } 26 | } 27 | 28 | array_delete(arr); 29 | } 30 | -------------------------------------------------------------------------------- /LibraryCPPClass/list.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "list.h" 3 | 4 | List::List() 5 | { 6 | } 7 | 8 | List::List(const List &a) 9 | { 10 | } 11 | 12 | List &List::operator=(const List &a) 13 | { 14 | return *this; 15 | } 16 | 17 | List::~List() 18 | { 19 | } 20 | 21 | List::Item *List::first() 22 | { 23 | return nullptr; 24 | } 25 | 26 | List::Item *List::insert(Data data) 27 | { 28 | return nullptr; 29 | } 30 | 31 | List::Item *List::insert_after(Item *item, Data data) 32 | { 33 | return nullptr; 34 | } 35 | 36 | List::Item *List::erase_first() 37 | { 38 | return nullptr; 39 | } 40 | 41 | List::Item *List::erase_next(Item *item) 42 | { 43 | return nullptr; 44 | } 45 | -------------------------------------------------------------------------------- /LibraryCPP/stack.h: -------------------------------------------------------------------------------- 1 | #ifndef STACK_H 2 | #define STACK_H 3 | 4 | // Stack 5 | // Stores integer values inside 6 | typedef int Data; 7 | 8 | struct Stack; 9 | 10 | // Creates empty stack 11 | Stack *stack_create(); 12 | 13 | // Deletes the stack 14 | void stack_delete(Stack *stack); 15 | 16 | // Pushes data on top of the stack 17 | // Should be O(1) on average 18 | void stack_push(Stack *stack, Data data); 19 | 20 | // Retrives the last element from the stack 21 | Data stack_get(const Stack *stack); 22 | 23 | // Removes the last element from the stack 24 | // Should be O(1) 25 | void stack_pop(Stack *stack); 26 | 27 | // Returns true if the stack is empty 28 | bool stack_empty(const Stack *stack); 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /LibraryCPP/queue.h: -------------------------------------------------------------------------------- 1 | #ifndef QUEUE_H 2 | #define QUEUE_H 3 | 4 | // Queue 5 | // Stores integer values inside 6 | typedef int Data; 7 | 8 | struct Queue; 9 | 10 | // Create empty queue 11 | Queue *queue_create(); 12 | 13 | // Deletes queue 14 | void queue_delete(Queue *queue); 15 | 16 | // Includes new element into the queue 17 | // Should be O(1) on average 18 | void queue_insert(Queue *queue, Data data); 19 | 20 | // Retrieves first element from the queue 21 | Data queue_get(const Queue *queue); 22 | 23 | // Removes first element from the queue 24 | // Should be O(1) on average 25 | void queue_remove(Queue *queue); 26 | 27 | // Returns true if the queue is empty 28 | bool queue_empty(const Queue *queue); 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /LibraryCPPTemplate/Tests/array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "array.h" 3 | 4 | typedef Array MyArray; 5 | 6 | int main() 7 | { 8 | MyArray *arr = new MyArray(10); 9 | 10 | if (arr->size() != 10) 11 | { 12 | std::cout << "Invalid array size\n"; 13 | return 1; 14 | } 15 | 16 | for (int i = 0 ; i < 10 ; ++i) 17 | arr->set(i, i * 2); 18 | 19 | MyArray copy(*arr); 20 | 21 | for (int i = 0 ; i < 10 ; ++i) 22 | { 23 | if (*arr->get(i) != i * 2 24 | || *copy.get(i) != i * 2) 25 | { 26 | std::cout << "Invalid array element " << i << "\n"; 27 | return 1; 28 | } 29 | } 30 | 31 | delete arr; 32 | } 33 | -------------------------------------------------------------------------------- /LibraryC/array.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "array.h" 3 | 4 | typedef struct Array 5 | { 6 | } Array; 7 | 8 | // create array 9 | Array *array_create(size_t size, FFree f) 10 | { 11 | return malloc(sizeof(Array)); 12 | } 13 | 14 | // delete array, free memory 15 | void array_delete(Array *arr) 16 | { 17 | free(arr); 18 | } 19 | 20 | // returns specified array element 21 | Data array_get(const Array *arr, size_t index) 22 | { 23 | return (Data)0; 24 | } 25 | 26 | // sets the specified array element to the value 27 | void array_set(Array *arr, size_t index, Data value) 28 | { 29 | } 30 | 31 | // returns array size 32 | size_t array_size(const Array *arr) 33 | { 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /LibraryCPPClass/array.h: -------------------------------------------------------------------------------- 1 | #ifndef ARRAY_H 2 | #define ARRAY_H 3 | 4 | #include 5 | 6 | typedef int Data; 7 | 8 | class Array 9 | { 10 | public: 11 | // create array 12 | explicit Array(size_t size); 13 | 14 | // copy constructor 15 | Array(const Array &a); 16 | 17 | // assignment operator 18 | Array &operator=(const Array &a); 19 | 20 | // delete array, free memory 21 | ~Array(); 22 | 23 | // returns specified array element 24 | Data get(size_t index) const; 25 | 26 | // sets the specified array element to the value 27 | void set(size_t index, Data value); 28 | 29 | // returns array size 30 | size_t size() const; 31 | 32 | private: 33 | // private data should be here 34 | }; 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /LibraryCPP/binaryHeap.h: -------------------------------------------------------------------------------- 1 | #ifndef BINARYHEAP_H 2 | #define BINARYHEAP_H 3 | 4 | #include 5 | 6 | typedef int (*Comparator)(const void*, const void*); 7 | typedef void (*Destructor)(void*); 8 | 9 | struct BinaryHeap; 10 | 11 | BinaryHeap* binaryHeap_create(const size_t size, Comparator comp, Destructor dest); 12 | 13 | void binaryHeap_swapData(BinaryHeap* heap, const size_t firstIndex, const size_t secondIndex); 14 | 15 | void binaryHeap_heapify(BinaryHeap* heap, int i); 16 | 17 | void binaryHeap_insert(BinaryHeap* heap, void* node); 18 | 19 | void* binaryHeap_extractMin(BinaryHeap* heap); 20 | 21 | void* binaryHeap_getMin(BinaryHeap* heap); 22 | 23 | size_t binaryHeap_getSize(BinaryHeap* heap); 24 | 25 | void binaryHeap_delete(BinaryHeap* heap); 26 | 27 | #endif -------------------------------------------------------------------------------- /Practice/sources/map1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | int n; 7 | std::cin >> n; 8 | std::string *word = new std::string[n]; 9 | std::string *def = new std::string[n]; 10 | for (int i = 0 ; i < n ; ++i) 11 | std::cin >> word[i] >> def[i]; 12 | 13 | std::string s; 14 | while (std::cin >> s) 15 | { 16 | bool found = false; 17 | for (int i = 0 ; !found && i < n ; ++i) 18 | { 19 | if (word[i] == s) 20 | { 21 | found = true; 22 | std::cout << def[i] << '\n'; 23 | } 24 | } 25 | if (!found) 26 | std::cout << "Not found\n"; 27 | } 28 | 29 | delete[] word; 30 | delete[] def; 31 | } 32 | -------------------------------------------------------------------------------- /Labs/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(Labs "lab1.cpp") 2 | target_include_directories(Labs PUBLIC ../LibraryCPP) 3 | target_link_libraries(Labs LibraryCPP) 4 | 5 | add_executable(Labs2 "lab2.cpp") 6 | target_include_directories(Labs2 PUBLIC ../LibraryCPP) 7 | target_link_libraries(Labs2 LibraryCPP) 8 | 9 | add_executable(Labs3 "lab3.cpp") 10 | target_include_directories(Labs3 PUBLIC ../LibraryCPP) 11 | target_link_libraries(Labs3 LibraryCPP) 12 | 13 | add_executable(Labs4 "lab4.cpp") 14 | include_directories(${CMAKE_SOURCE_DIR}/LibraryCPPTemplate) 15 | 16 | add_executable(Labs5 "lab5.cpp") 17 | include_directories(${CMAKE_SOURCE_DIR}/LibraryCPPTemplate) 18 | 19 | add_executable(Labs6 "lab6.cpp") 20 | target_include_directories(Labs6 PUBLIC ../LibraryCPP) 21 | target_link_libraries(Labs6 LibraryCPP) -------------------------------------------------------------------------------- /LibraryC/Tests/array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "array.h" 3 | 4 | int main() 5 | { 6 | Array *arr = array_create(10, [](void *p) { delete (int*)p; }); 7 | 8 | if (array_size(arr) != 10) 9 | { 10 | std::cout << "Invalid array size\n"; 11 | array_delete(arr); 12 | return 1; 13 | } 14 | 15 | for (int i = 0 ; i < 10 ; ++i) 16 | { 17 | int *d = new int; 18 | *d = i * 2; 19 | array_set(arr, i, d); 20 | } 21 | 22 | for (int i = 0 ; i < 10 ; ++i) 23 | { 24 | if (*(int*)array_get(arr, i) != i * 2) 25 | { 26 | std::cout << "Invalid array element " << i << "\n"; 27 | array_delete(arr); 28 | return 1; 29 | } 30 | } 31 | 32 | array_delete(arr); 33 | } 34 | -------------------------------------------------------------------------------- /.github/workflows/clangtidy.yml: -------------------------------------------------------------------------------- 1 | name: cpp-linter 2 | 3 | on: 4 | push: 5 | branches: [ master ] 6 | pull_request: 7 | branches: [ master ] 8 | 9 | jobs: 10 | cpp-linter: 11 | runs-on: ubuntu-latest 12 | steps: 13 | - uses: actions/checkout@v3 14 | - uses: cpp-linter/cpp-linter-action@v2 15 | id: linter 16 | env: 17 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} 18 | with: 19 | style: file 20 | tidy-checks: 'bugprone-*,performance-*,clang-analyzer-*,cppcoreguidelines-*,-cppcoreguidelines-avoid-magic-numbers,-cppcoreguidelines-init-variables,-cppcoreguidelines-owning-memory,-cppcoreguidelines-no-malloc,-cppcoreguidelines-avoid-c-arrays,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic' 21 | -------------------------------------------------------------------------------- /LibraryCPP/vector.h: -------------------------------------------------------------------------------- 1 | #ifndef VECTOR_H 2 | #define VECTOR_H 3 | 4 | #include 5 | 6 | // Vector (dynamic array) 7 | // Stores integer values inside 8 | typedef int Data; 9 | 10 | struct Vector; 11 | 12 | // Creates vector 13 | Vector *vector_create(); 14 | 15 | // Deletes vector structure and internal data 16 | void vector_delete(Vector *vector); 17 | 18 | // Retrieves vector element with the specified index 19 | Data vector_get(const Vector *vector, size_t index); 20 | 21 | // Sets vector element with the specified index 22 | void vector_set(Vector *vector, size_t index, Data value); 23 | 24 | // Retrieves current vector size 25 | size_t vector_size(const Vector *vector); 26 | 27 | // Changes the vector size (may increase or decrease) 28 | // Should be O(1) on average 29 | void vector_resize(Vector *vector, size_t size); 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /LibraryC/array.h: -------------------------------------------------------------------------------- 1 | #ifndef ARRAY_H 2 | #define ARRAY_H 3 | 4 | #include 5 | 6 | // Non-resizeable array 7 | // Stores pointer to custom user data 8 | typedef void* Data; 9 | // Custom function to free user pointers on delete 10 | typedef void (FFree)(void*); 11 | 12 | typedef struct Array Array; 13 | 14 | #ifdef __cplusplus 15 | extern "C" { 16 | #endif 17 | 18 | // create array 19 | Array *array_create(size_t size, FFree f); 20 | 21 | // delete array, free memory 22 | void array_delete(Array *arr); 23 | 24 | // returns specified array element 25 | Data array_get(const Array *arr, size_t index); 26 | 27 | // sets the specified array element to the value 28 | void array_set(Array *arr, size_t index, Data value); 29 | 30 | // returns array size 31 | size_t array_size(const Array *arr); 32 | 33 | #ifdef __cplusplus 34 | } 35 | #endif 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /LibraryCPPClass/stack.h: -------------------------------------------------------------------------------- 1 | #ifndef STACK_H 2 | #define STACK_H 3 | 4 | #include 5 | 6 | typedef int Data; 7 | 8 | class Stack 9 | { 10 | public: 11 | // Creates empty stack 12 | Stack(); 13 | 14 | // copy constructor 15 | Stack(const Stack &a); 16 | 17 | // assignment operator 18 | Stack &operator=(const Stack &a); 19 | 20 | // Deletes the stack 21 | ~Stack(); 22 | 23 | // Pushes data on top of the stack 24 | // Should be O(1) on average 25 | void push(Data data); 26 | 27 | // Retrives the last element from the stack 28 | Data get() const; 29 | 30 | // Removes the last element from the stack 31 | // Should be O(1) 32 | void pop(); 33 | 34 | // Returns true if the stack is empty 35 | bool empty() const; 36 | 37 | private: 38 | // private data should be here 39 | }; 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /LibraryCPPClass/queue.h: -------------------------------------------------------------------------------- 1 | #ifndef QUEUE_H 2 | #define QUEUE_H 3 | 4 | #include 5 | 6 | typedef int Data; 7 | 8 | class Queue 9 | { 10 | public: 11 | // Create empty queue 12 | Queue(); 13 | 14 | // copy constructor 15 | Queue(const Queue &a); 16 | 17 | // assignment operator 18 | Queue &operator=(const Queue &a); 19 | 20 | // Deletes queue 21 | ~Queue(); 22 | 23 | // Includes new element into the queue 24 | // Should be O(1) on average 25 | void insert(Data data); 26 | 27 | // Retrieves first element from the queue 28 | Data get() const; 29 | 30 | // Removes first element from the queue 31 | // Should be O(1) on average 32 | void remove(); 33 | 34 | // Returns true if the queue is empty 35 | bool empty() const; 36 | 37 | private: 38 | // private data should be here 39 | }; 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /Practice/title.tex: -------------------------------------------------------------------------------- 1 | \begin{titlepage} 2 | \newpage 3 | 4 | \begin{center} 5 | Министерство образования и науки Российской Федерации \\ 6 | \vspace{0.5em} 7 | Федеральное государственное бюджетное образовательное учреждение 8 | высшего профессионального образования 9 | <<Новгородский государственный университет \\ имени Ярослава Мудрого>> \\* 10 | \hrulefill 11 | \end{center} 12 | 13 | \vspace{4em} 14 | 15 | \begin{center} 16 | \bfseries 17 | \fontsize{15pt}{5pt}\selectfont 18 | П. М. Довгалюк 19 | \end{center} 20 | 21 | \vspace{0.7em} 22 | 23 | \begin{center} 24 | \scshape\bfseries\fontsize{20pt}{20pt}\selectfont 25 | Практикум на языке C++ 26 | \end{center} 27 | 28 | % \vspace{0.5em} 29 | % \begin{center} 30 | % \scshape\large 31 | % Монография 32 | % \end{center} 33 | 34 | \vspace{\fill} 35 | 36 | \begin{center} 37 | Великий Новгород \\ 2021 38 | \end{center} 39 | 40 | \end{titlepage} 41 | -------------------------------------------------------------------------------- /LibraryCPPClass/vector.h: -------------------------------------------------------------------------------- 1 | #ifndef VECTOR_H 2 | #define VECTOR_H 3 | 4 | #include 5 | 6 | typedef int Data; 7 | 8 | class Vector 9 | { 10 | public: 11 | // Creates vector 12 | Vector(); 13 | 14 | // copy constructor 15 | Vector(const Vector &a); 16 | 17 | // assignment operator 18 | Vector &operator=(const Vector &a); 19 | 20 | // Deletes vector structure and internal data 21 | ~Vector(); 22 | 23 | // Retrieves vector element with the specified index 24 | Data get(size_t index) const; 25 | 26 | // Sets vector element with the specified index 27 | void set(size_t index, Data value); 28 | 29 | // Retrieves current vector size 30 | size_t size() const; 31 | 32 | // Changes the vector size (may increase or decrease) 33 | // Should be O(1) on average 34 | void resize(size_t size); 35 | 36 | private: 37 | // private data should be here 38 | }; 39 | 40 | #endif 41 | -------------------------------------------------------------------------------- /LibraryCPP/stack.cpp: -------------------------------------------------------------------------------- 1 | #include "stack.h" 2 | #include "list.h" 3 | 4 | struct Stack 5 | { 6 | List* list; 7 | }; 8 | 9 | Stack* stack_create() 10 | { 11 | Stack* stack = new Stack; 12 | stack->list = list_create(); 13 | return stack; 14 | } 15 | 16 | void stack_delete(Stack* stack) 17 | { 18 | if (stack) 19 | { 20 | list_delete(stack->list); 21 | delete stack; 22 | } 23 | } 24 | 25 | void stack_push(Stack* stack, Data data) 26 | { 27 | list_insert(stack->list, data); 28 | } 29 | 30 | Data stack_get(const Stack* stack) 31 | { 32 | ListItem* first_item = list_first(stack->list); 33 | if (first_item) 34 | return list_item_data(first_item); 35 | else 36 | return (Data)0; 37 | } 38 | 39 | void stack_pop(Stack* stack) 40 | { 41 | list_erase_first(stack->list); 42 | } 43 | 44 | bool stack_empty(const Stack* stack) 45 | { 46 | return list_first(stack->list) == nullptr; 47 | } -------------------------------------------------------------------------------- /LibraryC/stack.h: -------------------------------------------------------------------------------- 1 | #ifndef STACK_H 2 | #define STACK_H 3 | 4 | #include 5 | 6 | // Stack 7 | // Stores pointer to custom user data 8 | typedef void* Data; 9 | // Custom function to free user pointers on delete 10 | typedef void (FFree)(void*); 11 | 12 | typedef struct Stack Stack; 13 | 14 | #ifdef __cplusplus 15 | extern "C" { 16 | #endif 17 | 18 | // Creates empty stack 19 | Stack *stack_create(FFree f); 20 | 21 | // Deletes the stack 22 | void stack_delete(Stack *stack); 23 | 24 | // Pushes data on top of the stack 25 | // Should be O(1) on average 26 | void stack_push(Stack *stack, Data data); 27 | 28 | // Retrives the last element from the stack 29 | Data stack_get(const Stack *stack); 30 | 31 | // Removes the last element from the stack 32 | // Should be O(1) 33 | void stack_pop(Stack *stack); 34 | 35 | // Returns true if the stack is empty 36 | bool stack_empty(const Stack *stack); 37 | 38 | #ifdef __cplusplus 39 | } 40 | #endif 41 | 42 | #endif 43 | -------------------------------------------------------------------------------- /LibraryC/queue.h: -------------------------------------------------------------------------------- 1 | #ifndef QUEUE_H 2 | #define QUEUE_H 3 | 4 | #include 5 | 6 | // Queue 7 | // Stores pointer to custom user data 8 | typedef void* Data; 9 | // Custom function to free user pointers on delete 10 | typedef void (FFree)(void*); 11 | 12 | typedef struct Queue Queue; 13 | 14 | #ifdef __cplusplus 15 | extern "C" { 16 | #endif 17 | 18 | // Create empty queue 19 | Queue *queue_create(FFree f); 20 | 21 | // Deletes queue 22 | void queue_delete(Queue *queue); 23 | 24 | // Includes new element into the queue 25 | // Should be O(1) on average 26 | void queue_insert(Queue *queue, Data data); 27 | 28 | // Retrieves first element from the queue 29 | Data queue_get(const Queue *queue); 30 | 31 | // Removes first element from the queue 32 | // Should be O(1) on average 33 | void queue_remove(Queue *queue); 34 | 35 | // Returns true if the queue is empty 36 | bool queue_empty(const Queue *queue); 37 | 38 | #ifdef __cplusplus 39 | } 40 | #endif 41 | 42 | #endif 43 | -------------------------------------------------------------------------------- /LibraryCPPTemplate/Tests/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(TestVectorCPPTemplate vector.cpp) 2 | target_include_directories(TestVectorCPPTemplate PUBLIC ..) 3 | add_test(TestVectorCPPTemplate TestVectorCPPTemplate) 4 | set_tests_properties(TestVectorCPPTemplate PROPERTIES TIMEOUT 10) 5 | 6 | add_executable(TestGraphCPPTemplate graph.cpp) 7 | target_include_directories(TestGraphCPPTemplate PUBLIC ..) 8 | add_test(TestGraphCPPTemplate TestGraphCPPTemplate) 9 | set_tests_properties(TestGraphCPPTemplate PROPERTIES TIMEOUT 10) 10 | 11 | add_executable(TestArrayCPPTemplate array.cpp) 12 | target_include_directories(TestArrayCPPTemplate PUBLIC ..) 13 | add_test(TestArrayCPPTemplate TestArrayCPPTemplate) 14 | set_tests_properties(TestArrayCPPTemplate PROPERTIES TIMEOUT 10) 15 | 16 | add_executable(TestHashCPPTemplate hash.cpp) 17 | target_include_directories(TestHashCPPTemplate PUBLIC ..) 18 | add_test(TestHashCPPTemplate TestHashCPPTemplate) 19 | set_tests_properties(TestHashCPPTemplate PROPERTIES TIMEOUT 10) -------------------------------------------------------------------------------- /LibraryCPPTemplate/Tests/hash.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "array.h" 5 | #include "hash.h" 6 | 7 | using namespace std; 8 | 9 | int main() { 10 | setlocale(LC_ALL, "rus"); 11 | 12 | HashTable* table = new HashTable(); 13 | 14 | size_t size_for_tests = 500000; //performance 15 | 16 | //add 17 | for (size_t i = 0; i < size_for_tests; i++) table->add(to_string(i), to_string(i)); 18 | 19 | for (size_t i = 0; i < 100; i++) 20 | { 21 | auto result = table->find(to_string(i)); 22 | if (!result.first || result.second != to_string(i)) { 23 | cout << "Searching or adding error\n"; 24 | } 25 | } 26 | 27 | //remove 28 | for (size_t i = 0; i < size_for_tests; i++) { table->del(to_string(i)); } 29 | 30 | //check 31 | for (size_t i = 100; i < 120; i++) 32 | { 33 | auto result = table->find(to_string(i)); 34 | if (result.first) { 35 | cout << "Search or insert error\n"; 36 | return 1; 37 | } 38 | } 39 | 40 | delete table; 41 | return 0; 42 | } -------------------------------------------------------------------------------- /LibraryC/Tests/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(TestArrayC array.cpp) 2 | target_include_directories(TestArrayC PUBLIC ..) 3 | target_link_libraries(TestArrayC LibraryC) 4 | add_test(TestArrayC TestArrayC) 5 | 6 | add_executable(TestListC list.cpp) 7 | target_include_directories(TestListC PUBLIC ..) 8 | target_link_libraries(TestListC LibraryC) 9 | add_test(TestListC TestListC) 10 | 11 | add_executable(TestQueueC queue.cpp) 12 | target_include_directories(TestQueueC PUBLIC ..) 13 | target_link_libraries(TestQueueC LibraryC) 14 | add_test(TestQueueC TestQueueC) 15 | set_tests_properties(TestQueueC PROPERTIES TIMEOUT 10) 16 | 17 | add_executable(TestStackC stack.cpp) 18 | target_include_directories(TestStackC PUBLIC ..) 19 | target_link_libraries(TestStackC LibraryC) 20 | add_test(TestStackC TestStackC) 21 | 22 | add_executable(TestVectorC vector.cpp) 23 | target_include_directories(TestVectorC PUBLIC ..) 24 | target_link_libraries(TestVectorC LibraryC) 25 | add_test(TestVectorC TestVectorC) 26 | set_tests_properties(TestVectorC PROPERTIES TIMEOUT 10) 27 | -------------------------------------------------------------------------------- /LibraryC/list.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "list.h" 3 | 4 | typedef struct ListItem 5 | { 6 | } ListItem; 7 | 8 | typedef struct List 9 | { 10 | } List; 11 | 12 | List *list_create(FFree f) 13 | { 14 | return malloc(sizeof(List)); 15 | } 16 | 17 | void list_delete(List *list) 18 | { 19 | // TODO: free items 20 | free(list); 21 | } 22 | 23 | ListItem *list_first(List *list) 24 | { 25 | return NULL; 26 | } 27 | 28 | Data list_item_data(const ListItem *item) 29 | { 30 | return (Data)0; 31 | } 32 | 33 | ListItem *list_item_next(ListItem *item) 34 | { 35 | return NULL; 36 | } 37 | 38 | ListItem *list_item_prev(ListItem *item) 39 | { 40 | return NULL; 41 | } 42 | 43 | ListItem *list_insert(List *list, Data data) 44 | { 45 | return NULL; 46 | } 47 | 48 | ListItem *list_insert_after(List *list, ListItem *item, Data data) 49 | { 50 | return NULL; 51 | } 52 | 53 | ListItem *list_erase_first(List *list) 54 | { 55 | return NULL; 56 | } 57 | 58 | ListItem *list_erase_next(List *list, ListItem *item) 59 | { 60 | return NULL; 61 | } 62 | -------------------------------------------------------------------------------- /LibraryC/vector.h: -------------------------------------------------------------------------------- 1 | #ifndef VECTOR_H 2 | #define VECTOR_H 3 | 4 | #include 5 | 6 | // Vector (dynamic array) 7 | // Stores pointer to custom user data 8 | typedef void* Data; 9 | // Custom function to free user pointers on delete 10 | typedef void (FFree)(void*); 11 | 12 | typedef struct Vector Vector; 13 | 14 | #ifdef __cplusplus 15 | extern "C" { 16 | #endif 17 | 18 | // Creates vector 19 | Vector *vector_create(FFree f); 20 | 21 | // Deletes vector structure and internal data 22 | void vector_delete(Vector *vector); 23 | 24 | // Retrieves vector element with the specified index 25 | Data vector_get(const Vector *vector, size_t index); 26 | 27 | // Sets vector element with the specified index 28 | void vector_set(Vector *vector, size_t index, Data value); 29 | 30 | // Retrieves current vector size 31 | size_t vector_size(const Vector *vector); 32 | 33 | // Changes the vector size (may increase or decrease) 34 | // Should be O(1) on average 35 | void vector_resize(Vector *vector, size_t size); 36 | 37 | #ifdef __cplusplus 38 | } 39 | #endif 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /LibraryCPPClass/Tests/list.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "list.h" 3 | 4 | int main() 5 | { 6 | List *list = new List; 7 | 8 | if (!list) 9 | { 10 | std::cout << "List creation error\n"; 11 | return 1; 12 | } 13 | 14 | list->insert(1); 15 | list->insert(2); 16 | list->insert(3); 17 | 18 | if (list->first()->data() != 3) 19 | { 20 | std::cout << "list_insert error\n"; 21 | return 1; 22 | } 23 | 24 | list->insert_after(list->first(), 4); 25 | 26 | if (list->first()->next()->data() != 4) 27 | { 28 | std::cout << "list_insert_after error\n"; 29 | return 1; 30 | } 31 | 32 | list->erase_first(); 33 | 34 | if (list->first()->data() != 4) 35 | { 36 | std::cout << "list_erase error\n"; 37 | return 1; 38 | } 39 | 40 | List copy(*list); 41 | 42 | std::cout << "List: "; 43 | for (auto item = list->first() ; item ; item = item->next()) 44 | { 45 | std::cout << item->data() << " "; 46 | } 47 | std::cout << "\n"; 48 | 49 | delete list; 50 | } 51 | -------------------------------------------------------------------------------- /LibraryCPP/priorityQueue.cpp: -------------------------------------------------------------------------------- 1 | #include "priorityQueue.h" 2 | 3 | struct PriorityQueue 4 | { 5 | BinaryHeap* heap; 6 | }; 7 | 8 | PriorityQueue* priorityQueue_create(const size_t size, Comparator comp, Destructor dest) 9 | { 10 | PriorityQueue* queue = new PriorityQueue; 11 | queue->heap = binaryHeap_create(size, comp, dest); 12 | return queue; 13 | } 14 | 15 | void priorityQueue_delete(PriorityQueue* queue) 16 | { 17 | binaryHeap_delete(queue->heap); 18 | delete queue; 19 | } 20 | 21 | void priorityQueue_insert(PriorityQueue* queue, void* data) 22 | { 23 | binaryHeap_insert(queue->heap, data); 24 | } 25 | 26 | void* priorityQueue_getMin(PriorityQueue* queue) 27 | { 28 | return binaryHeap_getMin(queue->heap); 29 | } 30 | 31 | void* priorityQueue_extractMin(PriorityQueue* queue) 32 | { 33 | return binaryHeap_extractMin(queue->heap); 34 | } 35 | 36 | size_t priorityQueue_getSize(PriorityQueue* queue) 37 | { 38 | return binaryHeap_getSize(queue->heap); 39 | } 40 | 41 | bool priorityQueue_empty(PriorityQueue* queue) 42 | { 43 | return binaryHeap_getSize(queue->heap) == 0; 44 | } -------------------------------------------------------------------------------- /LibraryCPPTemplate/Tests/list.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "list.h" 3 | 4 | typedef List MyList; 5 | 6 | int main() 7 | { 8 | MyList *list = new MyList; 9 | 10 | if (!list) 11 | { 12 | std::cout << "List creation error\n"; 13 | return 1; 14 | } 15 | 16 | list->insert(1); 17 | list->insert(2); 18 | list->insert(3); 19 | 20 | if (list->first()->data() != 3) 21 | { 22 | std::cout << "list_insert error\n"; 23 | return 1; 24 | } 25 | 26 | list->insert_after(list->first(), 4); 27 | 28 | if (list->first()->next()->data() != 4) 29 | { 30 | std::cout << "list_insert_after error\n"; 31 | return 1; 32 | } 33 | 34 | list->erase_first(); 35 | 36 | if (list->first()->data() != 4) 37 | { 38 | std::cout << "list_erase error\n"; 39 | return 1; 40 | } 41 | 42 | MyList copy(*list); 43 | 44 | std::cout << "List: "; 45 | for (auto item = list->first() ; item ; item = item->next()) 46 | { 47 | std::cout << item->data() << " "; 48 | } 49 | std::cout << "\n"; 50 | 51 | delete list; 52 | } 53 | -------------------------------------------------------------------------------- /LibraryCPPClass/Tests/stack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "stack.h" 3 | 4 | int main() 5 | { 6 | Stack stack; 7 | 8 | stack.push(1); 9 | stack.push(2); 10 | stack.push(3); 11 | 12 | if (stack.get() != 3) 13 | { 14 | std::cout << "Invalid stack top after push\n"; 15 | return 1; 16 | } 17 | 18 | std::cout << "Get: " << stack.get() << "\n"; 19 | stack.pop(); 20 | 21 | if (stack.get() != 2) 22 | { 23 | std::cout << "Invalid stack top after pop\n"; 24 | return 1; 25 | } 26 | 27 | std::cout << "Get: " << stack.get() << "\n"; 28 | stack.pop(); 29 | 30 | if (stack.get() != 1) 31 | { 32 | std::cout << "Invalid stack top after pop\n"; 33 | return 1; 34 | } 35 | 36 | std::cout << "Get: " << stack.get() << "\n"; 37 | stack.push(4); 38 | stack.push(5); 39 | 40 | if (stack.get() != 5) 41 | { 42 | std::cout << "Invalid stack top after push\n"; 43 | return 1; 44 | } 45 | 46 | while (!stack.empty()) 47 | { 48 | std::cout << "Get: " << stack.get() << "\n"; 49 | stack.pop(); 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /LibraryCPP/Tests/list.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "list.h" 3 | 4 | int main() 5 | { 6 | List *list = list_create(); 7 | 8 | if (!list) 9 | { 10 | std::cout << "List creation error\n"; 11 | return 1; 12 | } 13 | 14 | list_insert(list, 1); 15 | list_insert(list, 2); 16 | list_insert(list, 3); 17 | 18 | if (list_item_data(list_first(list)) != 3) 19 | { 20 | std::cout << "list_insert error\n"; 21 | return 1; 22 | } 23 | 24 | list_insert_after(list, list_first(list), 4); 25 | 26 | if (list_item_data(list_item_next(list_first(list))) != 4) 27 | { 28 | std::cout << "list_insert_after error\n"; 29 | return 1; 30 | } 31 | 32 | list_erase_first(list); 33 | 34 | if (list_item_data(list_first(list)) != 4) 35 | { 36 | std::cout << "list_erase error\n"; 37 | return 1; 38 | } 39 | 40 | std::cout << "List: "; 41 | for (ListItem *item = list_first(list) ; item ; item = list_item_next(item)) 42 | { 43 | std::cout << list_item_data(item) << " "; 44 | } 45 | std::cout << "\n"; 46 | 47 | list_delete(list); 48 | } 49 | -------------------------------------------------------------------------------- /LibraryCPPTemplate/stack.h: -------------------------------------------------------------------------------- 1 | #ifndef STACK_TEMPLATE_H 2 | #define STACK_TEMPLATE_H 3 | 4 | template class Stack 5 | { 6 | public: 7 | // Creates empty stack 8 | Stack() 9 | { 10 | } 11 | 12 | // copy constructor 13 | Stack(const Stack &a) 14 | { 15 | // implement or disable this function 16 | } 17 | 18 | // assignment operator 19 | Stack &operator=(const Stack &a) 20 | { 21 | // implement or disable this function 22 | return *this; 23 | } 24 | 25 | // Deletes the stack 26 | ~Stack() 27 | { 28 | } 29 | 30 | // Pushes data on top of the stack 31 | // Should be O(1) on average 32 | void push(Data data) 33 | { 34 | } 35 | 36 | // Retrives the last element from the stack 37 | Data get() const 38 | { 39 | return Data(); 40 | } 41 | 42 | // Removes the last element from the stack 43 | // Should be O(1) 44 | void pop() 45 | { 46 | } 47 | 48 | // Returns true if the stack is empty 49 | bool empty() const 50 | { 51 | return true; 52 | } 53 | 54 | private: 55 | // private data should be here 56 | }; 57 | 58 | #endif 59 | -------------------------------------------------------------------------------- /LibraryCPPTemplate/Tests/stack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "stack.h" 3 | 4 | typedef Stack MyStack; 5 | 6 | int main() 7 | { 8 | MyStack stack; 9 | 10 | stack.push(1); 11 | stack.push(2); 12 | stack.push(3); 13 | 14 | if (stack.get() != 3) 15 | { 16 | std::cout << "Invalid stack top after push\n"; 17 | return 1; 18 | } 19 | 20 | std::cout << "Get: " << stack.get() << "\n"; 21 | stack.pop(); 22 | 23 | if (stack.get() != 2) 24 | { 25 | std::cout << "Invalid stack top after pop\n"; 26 | return 1; 27 | } 28 | 29 | std::cout << "Get: " << stack.get() << "\n"; 30 | stack.pop(); 31 | 32 | if (stack.get() != 1) 33 | { 34 | std::cout << "Invalid stack top after pop\n"; 35 | return 1; 36 | } 37 | 38 | std::cout << "Get: " << stack.get() << "\n"; 39 | stack.push(4); 40 | stack.push(5); 41 | 42 | if (stack.get() != 5) 43 | { 44 | std::cout << "Invalid stack top after push\n"; 45 | return 1; 46 | } 47 | 48 | while (!stack.empty()) 49 | { 50 | std::cout << "Get: " << stack.get() << "\n"; 51 | stack.pop(); 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /LibraryCPPTemplate/queue.h: -------------------------------------------------------------------------------- 1 | #ifndef QUEUE_TEMPLATE_H 2 | #define QUEUE_TEMPLATE_H 3 | 4 | template class Queue 5 | { 6 | public: 7 | // Create empty queue 8 | Queue() 9 | { 10 | } 11 | 12 | // copy constructor 13 | Queue(const Queue &a) 14 | { 15 | // implement or disable this function 16 | } 17 | 18 | // assignment operator 19 | Queue &operator=(const Queue &a) 20 | { 21 | // implement or disable this function 22 | return *this; 23 | } 24 | 25 | // Deletes queue 26 | ~Queue() 27 | { 28 | } 29 | 30 | // Includes new element into the queue 31 | // Should be O(1) on average 32 | void insert(Data data) 33 | { 34 | } 35 | 36 | // Retrieves first element from the queue 37 | Data get() const 38 | { 39 | return Data(); 40 | } 41 | 42 | // Removes first element from the queue 43 | // Should be O(1) on average 44 | void remove() 45 | { 46 | } 47 | 48 | // Returns true if the queue is empty 49 | bool empty() const 50 | { 51 | return true; 52 | } 53 | 54 | private: 55 | // private data should be here 56 | }; 57 | 58 | #endif 59 | -------------------------------------------------------------------------------- /LibraryCPPClass/Tests/queue.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "queue.h" 3 | 4 | int main() 5 | { 6 | Queue *queue = new Queue(); 7 | 8 | queue->insert(1); 9 | queue->insert(2); 10 | queue->insert(3); 11 | 12 | if (queue->get() != 1) 13 | { 14 | std::cout << "Invalid first element of the queue\n"; 15 | return 1; 16 | } 17 | 18 | std::cout << "Get: " << queue->get() << "\n"; 19 | queue->remove(); 20 | 21 | if (queue->get() != 2) 22 | { 23 | std::cout << "Invalid second element of the queue\n"; 24 | return 1; 25 | } 26 | 27 | std::cout << "Get: " << queue->get() << "\n"; 28 | queue->remove(); 29 | 30 | if (queue->get() != 3) 31 | { 32 | std::cout << "Invalid third element of the queue\n"; 33 | return 1; 34 | } 35 | 36 | std::cout << "Get: " << queue->get() << "\n"; 37 | queue->insert(4); 38 | while (!queue->empty()) 39 | { 40 | std::cout << "Get: " << queue->get() << "\n"; 41 | queue->remove(); 42 | } 43 | 44 | // Performance test 45 | for (int i = 1 ; i <= 10000000 ; ++i) 46 | { 47 | queue->insert(i); 48 | } 49 | 50 | delete queue; 51 | } 52 | -------------------------------------------------------------------------------- /LibraryCPPTemplate/Tests/queue.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "queue.h" 3 | 4 | typedef Queue MyQueue; 5 | 6 | int main() 7 | { 8 | MyQueue *queue = new MyQueue(); 9 | 10 | queue->insert(1); 11 | queue->insert(2); 12 | queue->insert(3); 13 | 14 | if (queue->get() != 1) 15 | { 16 | std::cout << "Invalid first element of the queue\n"; 17 | return 1; 18 | } 19 | 20 | std::cout << "Get: " << queue->get() << "\n"; 21 | queue->remove(); 22 | 23 | if (queue->get() != 2) 24 | { 25 | std::cout << "Invalid second element of the queue\n"; 26 | return 1; 27 | } 28 | 29 | std::cout << "Get: " << queue->get() << "\n"; 30 | queue->remove(); 31 | 32 | if (queue->get() != 3) 33 | { 34 | std::cout << "Invalid third element of the queue\n"; 35 | return 1; 36 | } 37 | 38 | std::cout << "Get: " << queue->get() << "\n"; 39 | queue->insert(4); 40 | while (!queue->empty()) 41 | { 42 | std::cout << "Get: " << queue->get() << "\n"; 43 | queue->remove(); 44 | } 45 | 46 | // Performance test 47 | for (int i = 1 ; i <= 10000000 ; ++i) 48 | { 49 | queue->insert(i); 50 | } 51 | 52 | delete queue; 53 | } 54 | -------------------------------------------------------------------------------- /LibraryCPPClass/Tests/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(TestArrayCPPClass array.cpp) 2 | target_include_directories(TestArrayCPPClass PUBLIC ..) 3 | target_link_libraries(TestArrayCPPClass LibraryCPPClass) 4 | add_test(TestArrayCPPClass TestArrayCPPClass) 5 | 6 | add_executable(TestListCPPClass list.cpp) 7 | target_include_directories(TestListCPPClass PUBLIC ..) 8 | target_link_libraries(TestListCPPClass LibraryCPPClass) 9 | add_test(TestListCPPClass TestListCPPClass) 10 | 11 | add_executable(TestQueueCPPClass queue.cpp) 12 | target_include_directories(TestQueueCPPClass PUBLIC ..) 13 | target_link_libraries(TestQueueCPPClass LibraryCPPClass) 14 | add_test(TestQueueCPPClass TestQueueCPPClass) 15 | set_tests_properties(TestQueueCPPClass PROPERTIES TIMEOUT 10) 16 | 17 | add_executable(TestStackCPPClass stack.cpp) 18 | target_include_directories(TestStackCPPClass PUBLIC ..) 19 | target_link_libraries(TestStackCPPClass LibraryCPPClass) 20 | add_test(TestStackCPPClass TestStackCPPClass) 21 | 22 | add_executable(TestVectorCPPClass vector.cpp) 23 | target_include_directories(TestVectorCPPClass PUBLIC ..) 24 | target_link_libraries(TestVectorCPPClass LibraryCPPClass) 25 | add_test(TestVectorCPPClass TestVectorCPPClass) 26 | set_tests_properties(TestVectorCPPClass PROPERTIES TIMEOUT 10) 27 | -------------------------------------------------------------------------------- /LibraryCPP/Tests/queue.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "queue.h" 3 | 4 | int main() 5 | { 6 | Queue *queue = queue_create(); 7 | 8 | queue_insert(queue, 1); 9 | queue_insert(queue, 2); 10 | queue_insert(queue, 3); 11 | 12 | if (queue_get(queue) != 1) 13 | { 14 | std::cout << "Invalid first element of the queue\n"; 15 | return 1; 16 | } 17 | 18 | std::cout << "Get: " << queue_get(queue) << "\n"; 19 | queue_remove(queue); 20 | 21 | if (queue_get(queue) != 2) 22 | { 23 | std::cout << "Invalid second element of the queue\n"; 24 | return 1; 25 | } 26 | 27 | std::cout << "Get: " << queue_get(queue) << "\n"; 28 | queue_remove(queue); 29 | 30 | if (queue_get(queue) != 3) 31 | { 32 | std::cout << "Invalid third element of the queue\n"; 33 | return 1; 34 | } 35 | 36 | std::cout << "Get: " << queue_get(queue) << "\n"; 37 | queue_insert(queue, 4); 38 | while (!queue_empty(queue)) 39 | { 40 | std::cout << "Get: " << queue_get(queue) << "\n"; 41 | queue_remove(queue); 42 | } 43 | 44 | // Performance test 45 | for (int i = 1 ; i <= 10000000 ; ++i) 46 | { 47 | queue_insert(queue, i); 48 | } 49 | 50 | queue_delete(queue); 51 | } 52 | -------------------------------------------------------------------------------- /LibraryCPPClass/list.h: -------------------------------------------------------------------------------- 1 | #ifndef LIST_H 2 | #define LIST_H 3 | 4 | #include 5 | 6 | typedef int Data; 7 | 8 | class List 9 | { 10 | public: 11 | class Item 12 | { 13 | public: 14 | Item *next() { return nullptr; } 15 | Item *prev() { return nullptr; } 16 | Data data() const { return Data(); } 17 | private: 18 | // internal data here 19 | }; 20 | 21 | // Creates new list 22 | List(); 23 | 24 | // copy constructor 25 | List(const List &a); 26 | 27 | // assignment operator 28 | List &operator=(const List &a); 29 | 30 | // Destroys the list and frees the memory 31 | ~List(); 32 | 33 | // Retrieves the first item from the list 34 | Item *first(); 35 | 36 | // Inserts new list item into the beginning 37 | Item *insert(Data data); 38 | 39 | // Inserts new list item after the specified item 40 | Item *insert_after(Item *item, Data data); 41 | 42 | // Deletes the first list item. 43 | // Returns pointer to the item next to the deleted one. 44 | Item *erase_first(); 45 | 46 | // Deletes the list item following the specified one. 47 | // Returns pointer to the item next to the deleted one. 48 | // Should be O(1) 49 | Item *erase_next(Item *item); 50 | private: 51 | // private data should be here 52 | }; 53 | 54 | #endif 55 | -------------------------------------------------------------------------------- /LibraryCPP/list.h: -------------------------------------------------------------------------------- 1 | #ifndef LIST_H 2 | #define LIST_H 3 | 4 | // List 5 | // Stores integer values inside 6 | typedef int Data; 7 | 8 | struct List; 9 | struct ListItem; 10 | 11 | // Creates new list 12 | List *list_create(); 13 | 14 | // Destroys the list and frees the memory 15 | void list_delete(List *list); 16 | 17 | // Retrieves the first item from the list 18 | ListItem *list_first(List *list); 19 | 20 | // Extracts data from the list item 21 | Data list_item_data(const ListItem *item); 22 | 23 | // Returns list item following after the specified one 24 | ListItem *list_item_next(ListItem *item); 25 | 26 | // Returns previous element for the specified item. 27 | // Not applicable for the singly linked lists. 28 | ListItem *list_item_prev(ListItem *item); 29 | 30 | // Inserts new list item into the beginning 31 | ListItem *list_insert(List *list, Data data); 32 | 33 | // Inserts new list item after the specified item 34 | ListItem *list_insert_after(List *list, ListItem *item, Data data); 35 | 36 | // Deletes the first list item. 37 | // Returns pointer to the item next to the deleted one. 38 | ListItem *list_erase_first(List *list); 39 | 40 | // Deletes the list item following the specified one. 41 | // Returns pointer to the item next to the deleted one. 42 | // Should be O(1) 43 | ListItem *list_erase_next(List *list, ListItem *item); 44 | 45 | #endif 46 | -------------------------------------------------------------------------------- /LibraryCPP/Tests/stack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "stack.h" 3 | 4 | int main() 5 | { 6 | Stack *stack = stack_create(); 7 | 8 | stack_push(stack, 1); 9 | stack_push(stack, 2); 10 | stack_push(stack, 3); 11 | 12 | if (stack_get(stack) != 3) 13 | { 14 | std::cout << "Invalid stack top after push\n"; 15 | stack_delete(stack); 16 | return 1; 17 | } 18 | 19 | std::cout << "Get: " << stack_get(stack) << "\n"; 20 | stack_pop(stack); 21 | 22 | if (stack_get(stack) != 2) 23 | { 24 | std::cout << "Invalid stack top after pop\n"; 25 | stack_delete(stack); 26 | return 1; 27 | } 28 | 29 | std::cout << "Get: " << stack_get(stack) << "\n"; 30 | stack_pop(stack); 31 | 32 | if (stack_get(stack) != 1) 33 | { 34 | std::cout << "Invalid stack top after pop\n"; 35 | stack_delete(stack); 36 | return 1; 37 | } 38 | 39 | std::cout << "Get: " << stack_get(stack) << "\n"; 40 | stack_push(stack, 4); 41 | stack_push(stack, 5); 42 | 43 | if (stack_get(stack) != 5) 44 | { 45 | std::cout << "Invalid stack top after push\n"; 46 | stack_delete(stack); 47 | return 1; 48 | } 49 | 50 | while (!stack_empty(stack)) 51 | { 52 | std::cout << "Get: " << stack_get(stack) << "\n"; 53 | stack_pop(stack); 54 | } 55 | 56 | stack_delete(stack); 57 | } 58 | -------------------------------------------------------------------------------- /Practice/titleback.tex: -------------------------------------------------------------------------------- 1 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 2 | %% Используйте этот файл как шаблон для выходных сведений о вашем издании %% 3 | %% на обороте титульного листа %% 4 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 5 | {%\large 6 | \parindent=0cm 7 | \thispagestyle{empty} 8 | 9 | \begin{tabularx}{\textwidth}{cp{0.4\textwidth}p{0.6\textwidth}} 10 | ББК & 32.973.26-018.2 & Печатается по решению \\ 11 | & Д58 & РИС НовГУ \\ 12 | \end{tabularx} 13 | 14 | \vspace{1cm} 15 | 16 | \begin{center} 17 | Рецензенты: \\ 18 | рецензент 1 \\ 19 | рецензент 2 \\ 20 | \end{center} 21 | 22 | \vspace{1cm} 23 | 24 | % \vspace{0.06cm} 25 | % \vspace{0.6cm} 26 | 27 | \begin{tabularx}{\textwidth}{cp{0.9\textwidth}} 28 | & {\bf Довгалюк, П. М.} \\ 29 | Д58 & \hspace{3ex} Практикум на языке C++ / П.~М.~Довгалюк; 30 | НовГУ им.~Ярослава Мудрого. -- Великий Новгород, 2021. -- xx с. \vspace{0.32cm} \\ 31 | & \hspace{3ex} ... 32 | \\ 33 | & \hspace{3ex} Пособие предназначено для студентов первых курсов технических специальностей. \\ 34 | \end{tabularx} 35 | \\ 36 | \begin{flushright} 37 | %УДК 51(075.8) + 51(075.8) \\ 38 | ББК~32.973.26-018.2 \\ 39 | \end{flushright} 40 | 41 | \vfill 42 | \begin{tabularx}{\textwidth}{p{5cm}ll} 43 | & \copyright & Новгородский государственный \\ && университет,~2021 \\ 44 | & \copyright & П. М. Довгалюк,~2021 \\ 45 | \end{tabularx} 46 | } 47 | -------------------------------------------------------------------------------- /LibraryCPP/vector.cpp: -------------------------------------------------------------------------------- 1 | #include "vector.h" 2 | 3 | struct Vector 4 | { 5 | Data* data; 6 | size_t size; 7 | size_t max_size; 8 | 9 | Vector() { 10 | size = 0; 11 | max_size = 1; 12 | data = new Data[max_size]; 13 | } 14 | 15 | ~Vector() { 16 | delete[] data; 17 | } 18 | }; 19 | 20 | Vector* vector_create() 21 | { 22 | return new Vector; 23 | } 24 | 25 | void vector_delete(Vector* vector) 26 | { 27 | delete vector; 28 | } 29 | 30 | Data vector_get(const Vector* vector, size_t index) 31 | { 32 | size_t size = vector->size; 33 | if (size <= index) { 34 | throw "Error"; 35 | } 36 | return vector->data[index]; 37 | } 38 | 39 | void vector_set(Vector* vector, size_t index, Data value) 40 | { 41 | size_t size = vector->size; 42 | if (size <= index) { 43 | throw "Error"; 44 | } 45 | vector->data[index] = value; 46 | } 47 | 48 | size_t vector_size(const Vector* vector) 49 | { 50 | return vector->size; 51 | } 52 | 53 | void vector_resize(Vector* vector, size_t size) 54 | { 55 | if (size <= vector->max_size) { 56 | vector->size = size; 57 | return; 58 | } 59 | size_t _max_size = size * 2; 60 | Data* tmp = new Data[_max_size]; 61 | for (size_t i = 0; i < vector->size; i++) { 62 | tmp[i] = vector->data[i]; 63 | } 64 | delete[] vector->data; 65 | 66 | vector->data = tmp; 67 | vector->max_size = _max_size; 68 | vector->size = size; 69 | } -------------------------------------------------------------------------------- /LABS.md: -------------------------------------------------------------------------------- 1 | # Подготовка 2 | 3 | Зайти в репозиторий Algorithms и сделать fork - собственную копию. 4 | 5 | Затем скачать копию себе на компьютер и скомпилировать. Для сборки нужно иметь установленный cmake, 6 | он поддерживает как работу с Visual Studio, так и с компиляторами gcc и clang. 7 | 8 | git clone https://github.com/<логин>/Algorithms 9 | cd Algorithms 10 | mkdir build 11 | cd build 12 | cmake .. 13 | make 14 | 15 | # Требования к лабораторным работам 16 | 17 | * Решения отправляются с помощью Pull request 18 | * Должны проходить все релевантные тесты (проверяйте отчёт о тестировании при создании pull request) 19 | 20 | * Размер вектора должен домножаться на константу в случае его переполнения 21 | * Стек и очередь не должны ограничивать число сохраняемых значений 22 | * Дополнительные требования указаны в комментариях к заголовкам функций 23 | 24 | # Добавление нового решения задачи 25 | 26 | Добавить подкаталог и модифицировать основной файл CMakeLists.txt: 27 | 28 | add_subdirectory(Lab1C) 29 | 30 | В подкаталоге создать исходный файл с решением с CMakeLists.txt для его сборки: 31 | 32 | add_executable(Lab1C lab1.c) 33 | target_include_directories(Lab1C PUBLIC ../LibraryC) 34 | target_link_libraries(Lab1C LibraryC) 35 | 36 | В последних двух строчках нужно ссылаться на используемый вариант библиотеки. 37 | 38 | После этого в нужной библиотеке реализовать требуемый по условию контейнер, чтобы 39 | тесты и программа заработали правильно. 40 | 41 | Проверить тесты локально можно с помощью команды ctest, выполненной в подкаталоге build. 42 | 43 | -------------------------------------------------------------------------------- /LibraryC/list.h: -------------------------------------------------------------------------------- 1 | #ifndef LIST_H 2 | #define LIST_H 3 | 4 | // List 5 | // Stores pointer to custom user data 6 | typedef void* Data; 7 | // Custom function to free user pointers on delete 8 | typedef void (FFree)(void*); 9 | 10 | typedef struct List List; 11 | typedef struct ListItem ListItem; 12 | 13 | #ifdef __cplusplus 14 | extern "C" { 15 | #endif 16 | 17 | // Creates new list 18 | List *list_create(FFree f); 19 | 20 | // Destroys the list and frees the memory 21 | void list_delete(List *list); 22 | 23 | // Retrieves the first item from the list 24 | ListItem *list_first(List *list); 25 | 26 | // Extracts data from the list item 27 | Data list_item_data(const ListItem *item); 28 | 29 | // Returns list item following after the specified one 30 | ListItem *list_item_next(ListItem *item); 31 | 32 | // Returns previous element for the specified item. 33 | // Not applicable for the singly linked lists. 34 | ListItem *list_item_prev(ListItem *item); 35 | 36 | // Inserts new list item into the beginning 37 | ListItem *list_insert(List *list, Data data); 38 | 39 | // Inserts new list item after the specified item 40 | ListItem *list_insert_after(List *list, ListItem *item, Data data); 41 | 42 | // Deletes the specified list item. 43 | // Returns pointer to the item next to the deleted one. 44 | ListItem *list_erase_first(List *list); 45 | 46 | // Deletes the list item following the specified one. 47 | // Returns pointer to the item next to the deleted one. 48 | // Should be O(1) 49 | ListItem *list_erase_next(List *list, ListItem *item); 50 | 51 | #ifdef __cplusplus 52 | } 53 | #endif 54 | 55 | #endif 56 | -------------------------------------------------------------------------------- /LibraryC/Tests/list.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "list.h" 3 | 4 | void myfree(void *p) 5 | { 6 | delete (int*)p; 7 | } 8 | 9 | int main() 10 | { 11 | List *list = list_create(myfree); 12 | 13 | if (!list) 14 | { 15 | std::cout << "List creation error\n"; 16 | return 1; 17 | } 18 | 19 | list_insert(list, new int(1)); 20 | list_insert(list, new int(2)); 21 | list_insert(list, new int(3)); 22 | 23 | ListItem *item = list_first(list); 24 | if (!item) 25 | { 26 | std::cout << "list_insert error\n"; 27 | list_delete(list); 28 | return 1; 29 | } 30 | 31 | if (*(int*)list_item_data(item) != 3) 32 | { 33 | std::cout << "list_insert error\n"; 34 | list_delete(list); 35 | return 1; 36 | } 37 | 38 | list_insert_after(list, list_first(list), new int(4)); 39 | 40 | item = list_item_next(list_first(list)); 41 | if (!item) 42 | { 43 | std::cout << "list_insert_after error\n"; 44 | list_delete(list); 45 | return 1; 46 | } 47 | 48 | if (*(int*)list_item_data(item) != 4) 49 | { 50 | std::cout << "list_insert_after error\n"; 51 | list_delete(list); 52 | return 1; 53 | } 54 | 55 | list_erase_first(list); 56 | 57 | if (*(int*)list_item_data(list_first(list)) != 4) 58 | { 59 | std::cout << "list_erase error\n"; 60 | list_delete(list); 61 | return 1; 62 | } 63 | 64 | std::cout << "List: "; 65 | for (ListItem *it = list_first(list) ; it ; it = list_item_next(it)) 66 | { 67 | std::cout << *(int*)list_item_data(it) << " "; 68 | } 69 | std::cout << "\n"; 70 | 71 | list_delete(list); 72 | } 73 | -------------------------------------------------------------------------------- /LibraryC/Tests/queue.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "queue.h" 3 | 4 | int queue_get_int(Queue *q) 5 | { 6 | void *v = queue_get(q); 7 | if (!v) 8 | { 9 | std::cout << "Invalid queue_get\n"; 10 | queue_delete(q); 11 | exit(1); 12 | } 13 | return *(int*)v; 14 | } 15 | 16 | int main() 17 | { 18 | Queue *queue = queue_create([](void *p) { delete (int*)p; }); 19 | 20 | queue_insert(queue, new int(1)); 21 | queue_insert(queue, new int(2)); 22 | queue_insert(queue, new int(3)); 23 | 24 | if (queue_get_int(queue) != 1) 25 | { 26 | std::cout << "Invalid first element of the queue\n"; 27 | queue_delete(queue); 28 | return 1; 29 | } 30 | 31 | std::cout << "Get: " << queue_get_int(queue) << "\n"; 32 | queue_remove(queue); 33 | 34 | if (queue_get_int(queue) != 2) 35 | { 36 | std::cout << "Invalid second element of the queue\n"; 37 | queue_delete(queue); 38 | return 1; 39 | } 40 | 41 | std::cout << "Get: " << queue_get_int(queue) << "\n"; 42 | queue_remove(queue); 43 | 44 | if (queue_get_int(queue) != 3) 45 | { 46 | std::cout << "Invalid third element of the queue\n"; 47 | queue_delete(queue); 48 | return 1; 49 | } 50 | 51 | std::cout << "Get: " << queue_get_int(queue) << "\n"; 52 | queue_insert(queue, new int(4)); 53 | while (!queue_empty(queue)) 54 | { 55 | std::cout << "Get: " << queue_get_int(queue) << "\n"; 56 | queue_remove(queue); 57 | } 58 | 59 | // Performance test 60 | for (int i = 1 ; i <= 10000000 ; ++i) 61 | { 62 | queue_insert(queue, new int(i)); 63 | } 64 | 65 | queue_delete(queue); 66 | } 67 | -------------------------------------------------------------------------------- /.github/workflows/cmake.yml: -------------------------------------------------------------------------------- 1 | name: CMake 2 | 3 | on: 4 | push: 5 | branches: [ master ] 6 | pull_request: 7 | branches: [ master ] 8 | 9 | env: 10 | # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.) 11 | BUILD_TYPE: RelWithDebInfo 12 | 13 | jobs: 14 | build: 15 | # The CMake configure and build commands are platform agnostic and should work equally 16 | # well on Windows or Mac. You can convert this to a matrix build if you need 17 | # cross-platform coverage. 18 | # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix 19 | runs-on: ubuntu-latest 20 | 21 | steps: 22 | - uses: actions/checkout@v2 23 | 24 | - name: Configure CMake 25 | # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make. 26 | # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type 27 | run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_FLAGS_INIT="-fsanitize=address" -DCMAKE_C_FLAGS_INIT="-fsanitize=address" -DCMAKE_EXE_LINKER_FLAGS_INIT="-fsanitize=address" 28 | 29 | - name: Build 30 | # Build your program with the given configuration 31 | run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} 32 | 33 | - name: Test 34 | working-directory: ${{github.workspace}}/build 35 | # Execute tests defined by the CMake configuration. 36 | # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail 37 | run: ctest -C ${{env.BUILD_TYPE}} --output-on-failure 38 | -------------------------------------------------------------------------------- /LibraryCPPTemplate/list.h: -------------------------------------------------------------------------------- 1 | #ifndef LIST_TEMPLATE_H 2 | #define LIST_TEMPLATE_H 3 | 4 | template class List 5 | { 6 | public: 7 | class Item 8 | { 9 | public: 10 | Item *next() { return nullptr; } 11 | Item *prev() { return nullptr; } 12 | Data data() const { return Data(); } 13 | private: 14 | // internal data here 15 | }; 16 | 17 | // Creates new list 18 | List() 19 | { 20 | } 21 | 22 | // copy constructor 23 | template 24 | List(const List &a) 25 | { 26 | } 27 | 28 | // assignment operator 29 | template 30 | List &operator=(const List &a) 31 | { 32 | return *this; 33 | } 34 | 35 | // Destroys the list and frees the memory 36 | ~List() 37 | { 38 | } 39 | 40 | // Retrieves the first item from the list 41 | Item *first() 42 | { 43 | return nullptr; 44 | } 45 | 46 | // Inserts new list item into the beginning 47 | Item *insert(Data data) 48 | { 49 | return nullptr; 50 | } 51 | 52 | // Inserts new list item after the specified item 53 | Item *insert_after(Item *item, Data data) 54 | { 55 | return nullptr; 56 | } 57 | 58 | // Deletes the first list item. 59 | // Returns pointer to the item next to the deleted one. 60 | Item *erase_first() 61 | { 62 | return nullptr; 63 | } 64 | 65 | // Deletes the list item following the specified one. 66 | // Returns pointer to the item next to the deleted one. 67 | // Should be O(1) 68 | Item *erase_next(Item *item) 69 | { 70 | return nullptr; 71 | } 72 | private: 73 | // private data should be here 74 | }; 75 | 76 | #endif 77 | -------------------------------------------------------------------------------- /LibraryC/Tests/stack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "stack.h" 3 | 4 | void myfree(void *p) 5 | { 6 | delete (int*)p; 7 | } 8 | 9 | int stack_get_int(Stack *s) 10 | { 11 | void *v = stack_get(s); 12 | if (!v) 13 | { 14 | std::cout << "Invalid stack_get\n"; 15 | stack_delete(s); 16 | exit(1); 17 | } 18 | return *(int*)v; 19 | } 20 | 21 | int main() 22 | { 23 | Stack *stack = stack_create(myfree); 24 | 25 | stack_push(stack, new int(1)); 26 | stack_push(stack, new int(2)); 27 | stack_push(stack, new int(3)); 28 | 29 | if (stack_get_int(stack) != 3) 30 | { 31 | std::cout << "Invalid stack top after push\n"; 32 | stack_delete(stack); 33 | return 1; 34 | } 35 | 36 | std::cout << "Get: " << stack_get_int(stack) << "\n"; 37 | stack_pop(stack); 38 | 39 | if (stack_get_int(stack) != 2) 40 | { 41 | std::cout << "Invalid stack top after pop\n"; 42 | stack_delete(stack); 43 | return 1; 44 | } 45 | 46 | std::cout << "Get: " << stack_get_int(stack) << "\n"; 47 | stack_pop(stack); 48 | 49 | if (stack_get_int(stack) != 1) 50 | { 51 | std::cout << "Invalid stack top after pop\n"; 52 | stack_delete(stack); 53 | return 1; 54 | } 55 | 56 | std::cout << "Get: " << stack_get_int(stack) << "\n"; 57 | stack_push(stack, new int(4)); 58 | stack_push(stack, new int(5)); 59 | 60 | if (stack_get_int(stack) != 5) 61 | { 62 | std::cout << "Invalid stack top after push\n"; 63 | stack_delete(stack); 64 | return 1; 65 | } 66 | 67 | while (!stack_empty(stack)) 68 | { 69 | std::cout << "Get: " << stack_get_int(stack) << "\n"; 70 | stack_pop(stack); 71 | } 72 | 73 | stack_delete(stack); 74 | } 75 | -------------------------------------------------------------------------------- /LibraryCPPClass/Tests/vector.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "vector.h" 3 | 4 | int main() 5 | { 6 | Vector vector; 7 | 8 | vector.resize(5); 9 | if (vector.size() != 5) 10 | { 11 | std::cout << "Invalid resize\n"; 12 | return 1; 13 | } 14 | 15 | for (size_t i = 0 ; i < vector.size() ; ++i) 16 | vector.set(i, i); 17 | 18 | for (size_t i = 0 ; i < vector.size() ; ++i) 19 | { 20 | if (vector.get(i) != (int)i) 21 | { 22 | std::cout << "Invalid vector element " << i << "\n"; 23 | return 1; 24 | } 25 | } 26 | 27 | vector.resize(10); 28 | if (vector.size() != 10) 29 | { 30 | std::cout << "Invalid resize\n"; 31 | return 1; 32 | } 33 | 34 | std::cout << "Vector: "; 35 | for (size_t i = 0 ; i < vector.size() ; ++i) 36 | std::cout << vector.get(i) << " "; 37 | std::cout << "\n"; 38 | 39 | vector.resize(3); 40 | if (vector.size() != 3) 41 | { 42 | std::cout << "Invalid resize\n"; 43 | return 1; 44 | } 45 | 46 | for (size_t i = 0 ; i < vector.size() ; ++i) 47 | { 48 | if (vector.get(i) != (int)i) 49 | { 50 | std::cout << "Invalid vector element " << i << "\n"; 51 | return 1; 52 | } 53 | } 54 | 55 | std::cout << "Vector: "; 56 | for (size_t i = 0 ; i < vector.size() ; ++i) 57 | std::cout << vector.get(i) << " "; 58 | std::cout << "\n"; 59 | 60 | // Performance test 61 | for (int i = 1 ; i <= 10000000 ; ++i) 62 | { 63 | vector.resize(i); 64 | vector.set(i - 1, i); 65 | } 66 | 67 | Vector copy = vector; 68 | 69 | long long sum = 0; 70 | for (int i = 0 ; i < 10000000 ; ++i) 71 | sum += vector.get(i); 72 | 73 | std::cout << sum << "\n"; 74 | } 75 | -------------------------------------------------------------------------------- /LibraryCPPTemplate/Tests/graph.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "graph.h" 3 | 4 | typedef Graph MyGraph; 5 | 6 | int main() { 7 | size_t vertex_count = 5; 8 | MyGraph* graph = new MyGraph(vertex_count, 1); 9 | 10 | if (graph->getVertexAmount() != 5) { 11 | std::cout << "Invalid vertex amount\n"; 12 | return 1; 13 | } 14 | 15 | for (size_t i = 0; i < vertex_count; i++) { 16 | graph->getVertex(i)->setVertexData(static_cast(i)); 17 | } 18 | 19 | for (size_t i = 0; i < vertex_count; i++) { 20 | if (graph->getVertex(i)->getVertexData() != static_cast(i)) { 21 | std::cout << "Invalid vertex data\n"; 22 | return 1; 23 | } 24 | } 25 | 26 | graph->addEdge(2, 1, 15); 27 | graph->addEdge(0, 3, 3); 28 | 29 | if (!graph->isEdgeExist(2, 1)) { 30 | std::cout << "Invalid edge creation\n"; 31 | return 1; 32 | } 33 | 34 | auto it = graph->getIterator(0); 35 | while (*it != nullptr) { 36 | if ((*it)->getVertexData() != 3) { 37 | std::cout << "Invalid iteration\n"; 38 | return 1; 39 | } 40 | ++it; 41 | } 42 | 43 | if (graph->getEdge(2, 1)->getEdgeData() != 15) { 44 | std::cout << "Invalid edge data\n"; 45 | return 1; 46 | } 47 | 48 | graph->getEdge(0, 3)->setEdgeData(30); 49 | if (graph->getEdge(0, 3)->getEdgeData() != 30) { 50 | std::cout << "Invalid edge data setting\n"; 51 | return 1; 52 | } 53 | 54 | graph->removeEdge(2, 1); 55 | if (graph->isEdgeExist(2, 1)) { 56 | std::cout << "Invalid edge deletion\n"; 57 | return 1; 58 | } 59 | 60 | graph->removeVertex(3); 61 | if (graph->getVertexAmount() != 4) { 62 | std::cout << "Invalid vertex deletion\n"; 63 | return 1; 64 | } 65 | 66 | delete graph; 67 | } -------------------------------------------------------------------------------- /LibraryCPPTemplate/Tests/vector.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "vector.h" 3 | 4 | typedef Vector MyVector; 5 | 6 | int main() 7 | { 8 | MyVector vector; 9 | 10 | vector.resize(5); 11 | if (vector.size() != 5) 12 | { 13 | std::cout << "Invalid resize\n"; 14 | return 1; 15 | } 16 | 17 | for (size_t i = 0 ; i < vector.size() ; ++i) 18 | vector.set(i, static_cast(i)); 19 | 20 | for (size_t i = 0 ; i < vector.size() ; ++i) 21 | { 22 | if (vector.get(i) != (int)i) 23 | { 24 | std::cout << "Invalid vector element " << i << "\n"; 25 | return 1; 26 | } 27 | } 28 | 29 | vector.resize(10); 30 | if (vector.size() != 10) 31 | { 32 | std::cout << "Invalid resize\n"; 33 | return 1; 34 | } 35 | 36 | std::cout << "Vector: "; 37 | for (size_t i = 0 ; i < vector.size() ; ++i) 38 | std::cout << vector.get(i) << " "; 39 | std::cout << "\n"; 40 | 41 | vector.resize(3); 42 | if (vector.size() != 3) 43 | { 44 | std::cout << "Invalid resize\n"; 45 | return 1; 46 | } 47 | 48 | for (size_t i = 0 ; i < vector.size() ; ++i) 49 | { 50 | if (vector.get(i) != (int)i) 51 | { 52 | std::cout << "Invalid vector element " << i << "\n"; 53 | return 1; 54 | } 55 | } 56 | 57 | std::cout << "Vector: "; 58 | for (size_t i = 0 ; i < vector.size() ; ++i) 59 | std::cout << vector.get(i) << " "; 60 | std::cout << "\n"; 61 | 62 | // Performance test 63 | for (int i = 1 ; i <= 10000000 ; ++i) 64 | { 65 | vector.resize(i); 66 | vector.set(i - 1, i); 67 | } 68 | 69 | MyVector copy = vector; 70 | 71 | long long sum = 0; 72 | for (int i = 0 ; i < 10000000 ; ++i) 73 | sum += vector.get(i); 74 | 75 | std::cout << sum << "\n"; 76 | } 77 | -------------------------------------------------------------------------------- /LibraryCPP/Tests/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(TestArrayCPP array.cpp) 2 | target_include_directories(TestArrayCPP PUBLIC ..) 3 | target_link_libraries(TestArrayCPP LibraryCPP) 4 | add_test(TestArrayCPP TestArrayCPP) 5 | 6 | add_executable(TestListCPP list.cpp) 7 | target_include_directories(TestListCPP PUBLIC ..) 8 | target_link_libraries(TestListCPP LibraryCPP) 9 | add_test(TestListCPP TestListCPP) 10 | 11 | add_executable(TestStackCPP stack.cpp) 12 | target_include_directories(TestStackCPP PUBLIC ..) 13 | target_link_libraries(TestStackCPP LibraryCPP) 14 | add_test(TestStackCPP TestStackCPP) 15 | 16 | add_executable(TestVectorCPP vector.cpp) 17 | target_include_directories(TestVectorCPP PUBLIC ..) 18 | target_link_libraries(TestVectorCPP LibraryCPP) 19 | add_test(TestVectorCPP TestVectorCPP) 20 | 21 | add_executable(TestQueueCPP queue.cpp) 22 | target_include_directories(TestQueueCPP PUBLIC ..) 23 | target_link_libraries(TestQueueCPP LibraryCPP) 24 | add_test(TestQueueCPP TestQueueCPP) 25 | set_tests_properties(TestQueueCPP PROPERTIES TIMEOUT 10) 26 | 27 | add_executable(TestPriorityQueueCPP priorityQueue.cpp) 28 | target_include_directories(TestPriorityQueueCPP PUBLIC ..) 29 | target_link_libraries(TestPriorityQueueCPP LibraryCPP) 30 | add_test(TestPriorityQueueCPP TestPriorityQueueCPP) 31 | set_tests_properties(TestPriorityQueueCPP PROPERTIES TIMEOUT 10) 32 | 33 | add_executable(TestHuffmanTreeCPP huffmanTree.cpp) 34 | target_include_directories(TestHuffmanTreeCPP PUBLIC ..) 35 | target_link_libraries(TestHuffmanTreeCPP LibraryCPP) 36 | add_test(TestHuffmanTreeCPP TestHuffmanTreeCPP) 37 | set_tests_properties(TestHuffmanTreeCPP PROPERTIES TIMEOUT 10) 38 | 39 | add_executable(TestBinaryHeapCPP binaryHeap.cpp) 40 | target_include_directories(TestBinaryHeapCPP PUBLIC ..) 41 | target_link_libraries(TestBinaryHeapCPP LibraryCPP) 42 | add_test(TestBinaryHeapCPP TestBinaryHeapCPP) 43 | set_tests_properties(TestBinaryHeapCPP PROPERTIES TIMEOUT 10) -------------------------------------------------------------------------------- /LibraryCPP/Tests/vector.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "vector.h" 3 | 4 | int main() 5 | { 6 | Vector *vector = vector_create(); 7 | 8 | vector_resize(vector, 5); 9 | if (vector_size(vector) != 5) 10 | { 11 | std::cout << "Invalid resize\n"; 12 | return 1; 13 | } 14 | 15 | for (Data i = 0; i < static_cast(vector_size(vector)); ++i) 16 | vector_set(vector, i, i); 17 | 18 | for (size_t i = 0 ; i < vector_size(vector) ; ++i) 19 | { 20 | if (vector_get(vector, i) != (int)i) 21 | { 22 | std::cout << "Invalid vector element " << i << "\n"; 23 | return 1; 24 | } 25 | } 26 | 27 | vector_resize(vector, 10); 28 | if (vector_size(vector) != 10) 29 | { 30 | std::cout << "Invalid resize\n"; 31 | return 1; 32 | } 33 | 34 | std::cout << "Vector: "; 35 | for (size_t i = 0 ; i < vector_size(vector) ; ++i) 36 | std::cout << vector_get(vector, i) << " "; 37 | std::cout << "\n"; 38 | 39 | vector_resize(vector, 3); 40 | if (vector_size(vector) != 3) 41 | { 42 | std::cout << "Invalid resize\n"; 43 | return 1; 44 | } 45 | 46 | for (size_t i = 0 ; i < vector_size(vector) ; ++i) 47 | { 48 | if (vector_get(vector, i) != (int)i) 49 | { 50 | std::cout << "Invalid vector element " << i << "\n"; 51 | return 1; 52 | } 53 | } 54 | 55 | std::cout << "Vector: "; 56 | for (size_t i = 0 ; i < vector_size(vector) ; ++i) 57 | std::cout << vector_get(vector, i) << " "; 58 | std::cout << "\n"; 59 | 60 | // Performance test 61 | for (int i = 1 ; i <= 10000000 ; ++i) 62 | { 63 | vector_resize(vector, i); 64 | vector_set(vector, i - 1, i); 65 | } 66 | 67 | long long sum = 0; 68 | for (int i = 0 ; i < 10000000 ; ++i) 69 | sum += vector_get(vector, i); 70 | 71 | std::cout << sum << "\n"; 72 | 73 | vector_delete(vector); 74 | } 75 | -------------------------------------------------------------------------------- /LibraryC/Tests/vector.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "vector.h" 3 | 4 | void myfree(void *p) 5 | { 6 | delete (int*)p; 7 | } 8 | 9 | int vector_get_int(Vector *v, size_t i) 10 | { 11 | return *(int*)vector_get(v, i); 12 | } 13 | 14 | int main() 15 | { 16 | Vector *vector = vector_create(myfree); 17 | 18 | vector_resize(vector, 5); 19 | if (vector_size(vector) != 5) 20 | { 21 | std::cout << "Invalid resize\n"; 22 | return 1; 23 | } 24 | 25 | for (size_t i = 0 ; i < vector_size(vector) ; ++i) 26 | vector_set(vector, i, new int(i)); 27 | 28 | for (size_t i = 0 ; i < vector_size(vector) ; ++i) 29 | { 30 | if (vector_get_int(vector, i) != (int)i) 31 | { 32 | std::cout << "Invalid vector element " << i << "\n"; 33 | return 1; 34 | } 35 | } 36 | 37 | vector_resize(vector, 10); 38 | if (vector_size(vector) != 10) 39 | { 40 | std::cout << "Invalid resize\n"; 41 | return 1; 42 | } 43 | 44 | std::cout << "Vector: "; 45 | for (size_t i = 0 ; i < vector_size(vector) ; ++i) 46 | std::cout << vector_get_int(vector, i) << " "; 47 | std::cout << "\n"; 48 | 49 | vector_resize(vector, 3); 50 | if (vector_size(vector) != 3) 51 | { 52 | std::cout << "Invalid resize\n"; 53 | return 1; 54 | } 55 | 56 | for (size_t i = 0 ; i < vector_size(vector) ; ++i) 57 | { 58 | if (vector_get_int(vector, i) != (int)i) 59 | { 60 | std::cout << "Invalid vector element " << i << "\n"; 61 | return 1; 62 | } 63 | } 64 | 65 | std::cout << "Vector: "; 66 | for (size_t i = 0 ; i < vector_size(vector) ; ++i) 67 | std::cout << vector_get_int(vector, i) << " "; 68 | std::cout << "\n"; 69 | 70 | // Performance test 71 | for (int i = 1 ; i <= 10000000 ; ++i) 72 | { 73 | vector_resize(vector, i); 74 | vector_set(vector, i - 1, new int(i)); 75 | } 76 | 77 | long long sum = 0; 78 | for (int i = 0 ; i < 10000000 ; ++i) 79 | sum += vector_get_int(vector, i); 80 | 81 | std::cout << sum << "\n"; 82 | 83 | vector_delete(vector); 84 | } 85 | -------------------------------------------------------------------------------- /Labs/lab1.cpp: -------------------------------------------------------------------------------- 1 | #include "array.h" 2 | #include 3 | 4 | using namespace std; 5 | 6 | void task1(Array *arr) 7 | { 8 | size_t size = array_size(arr); 9 | size_t kolvo = 0; 10 | for (size_t i = 0; i < size; i++) { 11 | //достаточно проверять кратность для 2,3,5,7 для эффективности алгоритма 12 | if (array_get(arr, i) % 2 == 0 || array_get(arr, i) % 3 == 0 || array_get(arr, i) % 5 == 0 || array_get(arr, i) % 7 == 0) 13 | kolvo++; 14 | } 15 | cout << kolvo << endl; 16 | } 17 | 18 | void task2(Array *arr) 19 | { 20 | size_t currentID = 0; 21 | size_t maxSum = 0; 22 | size_t currentSum = 0; 23 | 24 | //int mas[] = { 2,2,2,2,2,1,1,1,1,1 }; 25 | //for (int i = 0; i < array_size(arr); ++i) { 26 | // array_set(arr, i, mas[i]); 27 | //} 28 | 29 | if (array_size(arr) <= 5) { 30 | for (size_t i = 0; i < array_size(arr); ++i) 31 | cout << array_get(arr, i) << endl; 32 | } 33 | else 34 | { 35 | currentSum = array_get(arr, 0) + array_get(arr, 1) + array_get(arr, 2) + array_get(arr, 3) + array_get(arr, 4); // записываем первые 5 значений 36 | maxSum = currentSum; 37 | for (size_t i = 1; i < array_size(arr) - 4; ++i) { 38 | currentSum = currentSum - array_get(arr, i-1) + array_get(arr, i + 4); //вычитаем первое в предыдущей сумме и добавляем последнее в новой 39 | if (currentSum > maxSum) { 40 | maxSum = currentSum; 41 | currentID = i; 42 | } 43 | } 44 | 45 | for (size_t i = currentID; i < currentID + 5; ++i) 46 | cout << array_get(arr, i) << endl; 47 | } 48 | } 49 | 50 | void CreateArray(Array* arr) { 51 | size_t size = array_size(arr); 52 | for (size_t i = 0; i < size; i++) 53 | array_set(arr, i, rand()); 54 | } 55 | 56 | int main() 57 | { 58 | srand((unsigned int)time(NULL)); //random 59 | Array *arr = NULL; 60 | size_t size; 61 | 62 | //create first array, release first task and delete first array 63 | cin >> size; 64 | arr = array_create(size); 65 | CreateArray(arr); 66 | task1(arr); 67 | array_delete(arr); 68 | 69 | //create second array, release second task and delete second array 70 | cin >> size; 71 | arr = array_create(size); 72 | CreateArray(arr); 73 | task2(arr); 74 | array_delete(arr); 75 | } -------------------------------------------------------------------------------- /LibraryCPP/list.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "list.h" 3 | 4 | struct ListItem 5 | { 6 | Data data; 7 | ListItem* next; 8 | ListItem* prev; 9 | }; 10 | 11 | struct List 12 | { 13 | ListItem* head; 14 | ListItem* tail; 15 | }; 16 | 17 | List* list_create() 18 | { 19 | List* list = new List; 20 | list->head = nullptr; 21 | list->tail = nullptr; 22 | return list; 23 | } 24 | 25 | void list_delete(List* list) 26 | { 27 | ListItem* current = list->head; 28 | while (current != nullptr) 29 | { 30 | ListItem* next = current->next; 31 | delete current; 32 | current = next; 33 | } 34 | delete list; 35 | } 36 | 37 | ListItem* list_first(List* list) 38 | { 39 | return list->head; 40 | } 41 | 42 | Data list_item_data(const ListItem* item) 43 | { 44 | return item->data; 45 | } 46 | 47 | ListItem* list_item_next(ListItem* item) 48 | { 49 | return item->next; 50 | } 51 | 52 | ListItem* list_item_prev(ListItem* item) 53 | { 54 | return item->prev; 55 | } 56 | 57 | ListItem* list_insert(List* list, Data data) 58 | { 59 | ListItem* item = new ListItem{ data, nullptr, nullptr }; 60 | if (list->head == nullptr) 61 | { 62 | list->head = item; 63 | list->tail = item; 64 | } 65 | else 66 | { 67 | item->next = list->head; 68 | list->head->prev = item; 69 | list->head = item; 70 | } 71 | return item; 72 | } 73 | 74 | ListItem* list_insert_after(List* list, ListItem* item, Data data) 75 | { 76 | if (item == nullptr) 77 | return nullptr; 78 | ListItem* new_item = new ListItem{ data, nullptr, nullptr }; 79 | if (new_item == nullptr) 80 | return nullptr; 81 | 82 | new_item->next = item->next; 83 | new_item->prev = item; 84 | 85 | if (item->next != nullptr) 86 | item->next->prev = new_item; 87 | else 88 | list->tail = new_item; 89 | 90 | item->next = new_item; 91 | return new_item; 92 | } 93 | 94 | ListItem* list_erase_first(List* list) 95 | { 96 | if (list->head == nullptr) 97 | return nullptr; 98 | 99 | ListItem* item = list->head; 100 | list->head = item->next; 101 | if (list->head != nullptr) 102 | list->head->prev = nullptr; 103 | else 104 | list->tail = nullptr; 105 | 106 | delete item; 107 | return list->head; 108 | } 109 | 110 | ListItem* list_erase_next(List* list, ListItem* item) 111 | { 112 | if (item == nullptr || item->next == nullptr) 113 | return nullptr; 114 | 115 | ListItem* to_remove = item->next; 116 | item->next = to_remove->next; 117 | 118 | if (to_remove->next != nullptr) 119 | to_remove->next->prev = item; 120 | else 121 | list->tail = item; 122 | 123 | delete to_remove; 124 | return item->next; 125 | } -------------------------------------------------------------------------------- /Labs/lab5.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include // Библиотека для работы с временем 5 | #include "hash.h" // Подключение заголовочного файла для пользовательской хеш-таблицы 6 | 7 | using namespace std; 8 | 9 | // Массив символов, используемых для генерации случайных слов 10 | const char symbols[] = { "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" }; 11 | 12 | // Функция для генерации случайного слова 13 | string random_word() { 14 | int size = rand() % 10 + 1; // Случайный размер слова от 1 до 10 символов 15 | string str; 16 | for (int i = 0; i < size; i++) str.push_back(symbols[rand() % 62]); // Генерация слова 17 | return str; 18 | } 19 | 20 | // Функция для тестирования хеш-таблицы 21 | void execute(HashTable* table, int size) { 22 | unordered_map map; // Стандартная хеш-таблица из STL 23 | 24 | // Переменные для измерения времени 25 | chrono::system_clock::time_point start_table; 26 | chrono::system_clock::time_point table_end; 27 | chrono::system_clock::time_point start_map; 28 | chrono::system_clock::time_point map_end; 29 | 30 | chrono::duration time_table; // Время выполнения для пользовательской хеш-таблицы 31 | chrono::duration time_map; // Время выполнения для unordered_map 32 | 33 | // Создание массивов для случайных ключей и значений 34 | string* random_value = new string[size]; 35 | string* random_key = new string[size]; 36 | 37 | // Заполнение массивов случайными словами 38 | for (int i = 0; i < size; i++) random_value[i] = random_word(); 39 | for (int i = 0; i < size; i++) random_key[i] = random_word(); 40 | 41 | // Тестирование пользовательской хеш-таблицы 42 | start_table = chrono::system_clock::now(); 43 | for (int i = 0; i < size; i++) table->add(random_key[i], random_value[i]); 44 | table_end = chrono::system_clock::now(); 45 | time_table = table_end - start_table; 46 | 47 | // Тестирование unordered_map 48 | start_map = chrono::system_clock::now(); 49 | for (int i = 0; i < size; i++) map[random_key[i]] = random_value[i]; 50 | map_end = chrono::system_clock::now(); 51 | time_map = map_end - start_map; 52 | 53 | // Вывод результатов тестирования 54 | cout << "Added " << size << " elements. My table is " << time_table.count() << ". Unordered_map is " << time_map.count() << ".\n"; 55 | 56 | // Освобождение памяти, занятой массивами ключей и значений 57 | delete[] random_key; 58 | delete[] random_value; 59 | } 60 | 61 | // Главная функция программы 62 | int main() { 63 | setlocale(LC_ALL, "rus"); // Установка русской локализации 64 | srand((unsigned int)time(NULL)); // Инициализация генератора случайных чисел 65 | 66 | // Создание экземпляра пользовательской хеш-таблицы 67 | HashTable* table = new HashTable(); 68 | 69 | // Выполнение тестирования для различного количества элементов 70 | execute(table, 100); 71 | execute(table, 500); 72 | execute(table, 1000); 73 | execute(table, 5000); 74 | execute(table, 10000); 75 | execute(table, 50000); 76 | execute(table, 100000); 77 | execute(table, 500000); 78 | 79 | // Освобождение памяти, занятой хеш-таблицей 80 | delete table; 81 | 82 | 83 | //HashTable* table2 = new HashTable(); 84 | //table2->add("@","1"); 85 | //table2->add("P", "2"); 86 | //table2->del("@"); 87 | //cout<<(table2->find("P").second)< 2 | #include 3 | #include 4 | #include 5 | #include "stack.h" 6 | 7 | int main() { 8 | Stack* stack = stack_create(); 9 | int variables[4] = { 0, 0, 0, 0 }; 10 | 11 | std::ifstream inputFile("input.txt"); //D:\VisualStudioRepo\Algorithms\out\build\x64-debug\Labs - мое расположения файла. Он должен быть там, где собирается .exe файл решения 12 | if (!inputFile.is_open()) { 13 | std::cerr << "Failed open!" << std::endl; 14 | return 1; 15 | } 16 | 17 | std::string line; 18 | while (std::getline(inputFile, line)) { 19 | std::istringstream iss(line); 20 | std::string operation; 21 | iss >> operation; 22 | 23 | if (operation == "bipush") { 24 | int value; 25 | if (iss >> value) { 26 | stack_push(stack, value); 27 | } 28 | } 29 | else if (operation == "pop") { 30 | stack_pop(stack); 31 | } 32 | else if (operation == "imul") { 33 | int a = stack_get(stack); 34 | stack_pop(stack); 35 | int b = stack_get(stack); 36 | stack_pop(stack); 37 | stack_push(stack, a * b); 38 | } 39 | else if (operation == "iand") { 40 | int a = stack_get(stack); 41 | stack_pop(stack); 42 | int b = stack_get(stack); 43 | stack_pop(stack); 44 | stack_push(stack, a & b); 45 | } 46 | else if (operation == "ior") { 47 | int a = stack_get(stack); 48 | stack_pop(stack); 49 | int b = stack_get(stack); 50 | stack_pop(stack); 51 | stack_push(stack, a | b); 52 | } 53 | else if (operation == "ixor") { 54 | int a = stack_get(stack); 55 | stack_pop(stack); 56 | int b = stack_get(stack); 57 | stack_pop(stack); 58 | stack_push(stack, a ^ b); 59 | } 60 | else if (operation == "iadd") { 61 | int a = stack_get(stack); 62 | stack_pop(stack); 63 | int b = stack_get(stack); 64 | stack_pop(stack); 65 | stack_push(stack, a + b); 66 | } 67 | else if (operation == "isub") { 68 | int a = stack_get(stack); 69 | stack_pop(stack); 70 | int b = stack_get(stack); 71 | stack_pop(stack); 72 | stack_push(stack, b - a); 73 | } 74 | else if (operation == "iload_0") { 75 | stack_push(stack, variables[0]); 76 | } 77 | else if (operation == "iload_1") { 78 | stack_push(stack, variables[1]); 79 | } 80 | else if (operation == "iload_2") { 81 | stack_push(stack, variables[2]); 82 | } 83 | else if (operation == "iload_3") { 84 | stack_push(stack, variables[3]); 85 | } 86 | else if (operation == "istore_0") { 87 | variables[0] = stack_get(stack); 88 | stack_pop(stack); 89 | } 90 | else if (operation == "istore_1") { 91 | variables[1] = stack_get(stack); 92 | stack_pop(stack); 93 | } 94 | else if (operation == "istore_2") { 95 | variables[2] = stack_get(stack); 96 | stack_pop(stack); 97 | } 98 | else if (operation == "istore_3") { 99 | variables[3] = stack_get(stack); 100 | stack_pop(stack); 101 | } 102 | else if (operation == "swap") { 103 | int a = stack_get(stack); 104 | stack_pop(stack); 105 | int b = stack_get(stack); 106 | stack_pop(stack); 107 | stack_push(stack, a); 108 | stack_push(stack, b); 109 | } 110 | } 111 | inputFile.close(); 112 | 113 | std::cout << "stack:" << std::endl; 114 | while (!stack_empty(stack)) { 115 | std::cout << stack_get(stack) << std::endl; 116 | stack_pop(stack); 117 | } 118 | 119 | std::cout << "vars:" << std::endl; 120 | for (int i = 0; i < 4; ++i) { 121 | std::cout << variables[i] << std::endl; 122 | } 123 | 124 | stack_delete(stack); 125 | 126 | return 0; 127 | } -------------------------------------------------------------------------------- /Labs/lab3.cpp: -------------------------------------------------------------------------------- 1 | #include "queue.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | vector Read(int& sx, int& sy, Queue* queue, int& fx, int& fy) { 9 | vector labirynth; 10 | string strbuf; 11 | ifstream out("maze.txt"); 12 | int k = 0; 13 | while (getline(out, strbuf)) 14 | { 15 | labirynth.push_back(strbuf); 16 | for (size_t i = 0; i < labirynth[k].size(); i++) 17 | { 18 | if (labirynth[k][i] == 'X') 19 | { 20 | sx = static_cast(k); 21 | sy = static_cast(i); 22 | queue_insert(queue, sx); 23 | queue_insert(queue, sy); 24 | } 25 | if (labirynth[k][i] == 'Y') 26 | { 27 | fx = static_cast(k); 28 | fy = static_cast(i); 29 | } 30 | } 31 | k++; 32 | } 33 | out.close(); 34 | return labirynth; 35 | } 36 | //выделяет память и инициализирует двумерный массив rast, представляющий карту расстояний в лабиринте. Этот массив будет использоваться для хранения расстояний от начальной позиции до каждой ячейки в лабиринте. 37 | int** setter(vector& labirynth, int sx, int sy) { 38 | int** rast = new int* [labirynth.size()]; 39 | for (size_t i = 0; i < labirynth.size(); i++) 40 | { 41 | rast[i] = new int[labirynth[i].size()]; 42 | for (size_t l = 0; l < labirynth[i].size(); l++) 43 | { 44 | rast[i][l] = 0; 45 | } 46 | } 47 | rast[sx][sy] = 1; 48 | return rast; 49 | } 50 | //выполняет алгоритм поиска в ширину (BFS) для определения кратчайших расстояний от начальной позиции (X) до всех других доступных ячеек в лабиринте. 51 | void Check(Queue* queue, vector& labirynth, const int* dx, const int* dy, int** rast) { 52 | while (!queue_empty(queue)) 53 | { 54 | //получаем текущий x y из очереди 55 | int x = queue_get(queue); 56 | queue_remove(queue); 57 | int y = queue_get(queue); 58 | queue_remove(queue); 59 | //Проходим по всем направлениям (вверх, вниз, вправо, влево) 60 | for (int k_k = 0; k_k < 4; k_k++) 61 | { 62 | int xx = x + dx[k_k]; 63 | int yy = y + dy[k_k]; 64 | //Проверяется, что новые координаты находятся в пределах лабиринта. 65 | if (xx >= 0 && xx < static_cast(labirynth.size()) && yy >= 0 && yy < static_cast(labirynth[1].size())) 66 | { 67 | if (rast[xx][yy] == 0 && labirynth[xx][yy] != '#') 68 | { 69 | //Устанавливается новое расстояние от начальной позиции до текущей ячейки 70 | rast[xx][yy] = rast[x][y] + 1; 71 | //вставляем новые координаты в очередь 72 | queue_insert(queue, static_cast(xx)); 73 | queue_insert(queue, static_cast(yy)); 74 | } 75 | } 76 | } 77 | } 78 | } 79 | //печать кротчайшего пути 80 | void PrintAndClear(int** rast, vector labirynth, int fx, int fy, const int* dx, const int* dy, Queue* queue) { 81 | if (rast[fx][fy]) //существует ли путь от начала до конца 82 | { 83 | while (rast[fx][fy] - 1 != 1) // пока не достигли начальной точки 84 | { 85 | //Проходим по всем направлениям (вверх, вниз, вправо, влево) 86 | for (int k_k = 0; k_k < 4; k_k++) 87 | { 88 | int x = fx + dx[k_k]; 89 | int y = fy + dy[k_k]; 90 | 91 | //Если найдена ячейка на предыдущем шаге (расстояние от текущей позиции на 1 меньше), она помечается символом 'x', и текущая позиция обновляется на эту ячейку 92 | if (rast[fx][fy] - 1 == rast[x][y]) 93 | { 94 | labirynth[x][y] = 'x'; 95 | fx = x; 96 | fy = y; 97 | } 98 | } 99 | } 100 | for (size_t l = 0; l < labirynth.size(); l++) 101 | cout << labirynth[l] << endl; 102 | } 103 | else 104 | cout << "IMPOSSIBLE" << endl; 105 | 106 | for (size_t i = 0; i < labirynth.size(); i++) 107 | delete[] rast[i]; 108 | 109 | delete[] rast; 110 | queue_delete(queue); 111 | } 112 | 113 | int main() 114 | { 115 | Queue* queue = queue_create(); 116 | //смещения по оси y для движения вверх, вниз, вправо и влево. 117 | static const int dy[4] = { 0, 0, 1,-1 }; 118 | //смещения по оси x для движения вверх, вниз, вправо и влево. 119 | static const int dx[4] = { -1, 1, 0, 0 }; 120 | //начальные и конечные координаты x и y 121 | int sx = 0, sy = 0; 122 | int fx = 0, fy = 0; 123 | vector labirynth = Read(sx, sy, queue, fx, fy); 124 | int** rast = setter(labirynth, sx, sy); 125 | Check(queue, labirynth, dx, dy, rast); 126 | PrintAndClear(rast, labirynth,fx, fy, dx, dy, queue); 127 | return 0; 128 | } 129 | 130 | //Первый код использует дополнительные массивы для отслеживания посещенных ячеек(tag_map) и расстояний(routes). 131 | //Это может замедлить код, так как каждый раз при доступе к ячейке лабиринта также осуществляется доступ к соответствующим ячейкам в этих массивах. 132 | //Второй код использует только один дополнительный массив(rast) для хранения расстояний. -------------------------------------------------------------------------------- /Labs/lab4.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "graph.h" 5 | #include 6 | 7 | const int INF = INT_MAX; 8 | 9 | // Шаблонная функция для алгоритма Дейкстры 10 | template 11 | Vector dijkstra(const Graph& graph, size_t vertex_amount, size_t start_vertex) { 12 | // Создание немодифицируемой копии графа, чтобы обойти ограничения константности 13 | Graph mutableGraph = graph; 14 | 15 | // Установка всех расстояний до вершин в бесконечность, кроме начальной вершины 16 | for (size_t i = 0; i < vertex_amount; ++i) { 17 | mutableGraph.getVertex(i)->setVertexData(INF); 18 | } 19 | // Установка расстояния от начальной вершины до самой себя в 0 20 | mutableGraph.getVertex(start_vertex)->setVertexData(0); 21 | 22 | // Очередь с приоритетами для отслеживания вершин и их расстояний 23 | 24 | // 1. std::pair - тип хранимых элементов: пары, включающие расстояние и индекс вершины 25 | // 2. std::vector> - контейнер, используемый внутри для хранения элементов 26 | // 3. std::greater> - функциональный объект для сравнения элементов 27 | std::priority_queue, std::vector>, std::greater>> minHeap; 28 | // Добавление начальной вершины в очередь с приоритетами 29 | minHeap.push(std::make_pair(0, start_vertex)); 30 | 31 | // Основной цикл алгоритма Дейкстры 32 | // Цикл продолжается до тех пор, пока есть вершины для обработки в приоритетной очереди 33 | while (!minHeap.empty()) { 34 | // Извлечение пары с наименьшим расстоянием и соответствующего индекса вершины из кучи 35 | int distance = minHeap.top().first; // Текущее кратчайшее известное расстояние до вершины 36 | size_t current_vertex = minHeap.top().second; // Индекс текущей вершины 37 | minHeap.pop(); // Удаление этой пары из кучи 38 | 39 | // Если расстояние в вершине уже меньше извлеченного расстояния, то мы уже нашли более короткий путь, 40 | // и текущую вершину можно пропустить 41 | if (distance > mutableGraph.getVertex(current_vertex)->getVertexData()) 42 | continue; 43 | 44 | // Получаем итератор для обхода всех соседних вершин текущей вершины 45 | typename Graph::Iterator it = mutableGraph.getIterator(current_vertex); 46 | while (*it) { // Пока существуют соседние вершины 47 | size_t neighbor_index = it.getEnd(); // Индекс текущего соседа 48 | // Проверяем, есть ли ребро между текущей и соседней вершинами 49 | typename Graph::Edge* edge = mutableGraph.getEdge(current_vertex, neighbor_index); 50 | assert(edge != nullptr); // Утверждение, что такое ребро должно существовать 51 | int edge_weight = edge->getEdgeData(); // Вес ребра 52 | 53 | // Считаем потенциально новое расстояние до соседней вершины 54 | int current_vertex_data = mutableGraph.getVertex(current_vertex)->getVertexData(); 55 | int neighbor_vertex_data = mutableGraph.getVertex(neighbor_index)->getVertexData(); 56 | 57 | // Если сумма текущего расстояния и веса ребра меньше известного расстояния до соседа, 58 | // то обновляем значение расстояния в соседней вершине 59 | if (current_vertex_data + edge_weight < neighbor_vertex_data) { 60 | mutableGraph.getVertex(neighbor_index)->setVertexData(current_vertex_data + edge_weight); 61 | // Добавляем соседнюю вершину в кучу с обновленным расстоянием для дальнейшей обработки 62 | minHeap.push(std::make_pair(mutableGraph.getVertex(neighbor_index)->getVertexData(), neighbor_index)); 63 | } 64 | 65 | ++it; // Переходим к следующему соседу 66 | } 67 | } 68 | 69 | // Подготовка вектора для хранения результатов алгоритма 70 | Vector result; 71 | result.resize(vertex_amount); 72 | for (size_t i = 0; i < vertex_amount; ++i) { 73 | result.set(i, mutableGraph.getVertex(i)->getVertexData()); 74 | } 75 | 76 | return result; // Возврат вектора с кратчайшими расстояниями от начальной вершины 77 | } 78 | 79 | int main() { 80 | size_t vertex_amount = 0; // Общее количество вершин 81 | int N = 0; // Количество рёбер для чтения 82 | 83 | // Ввод количества вершин 84 | std::cout << "Input vertex_amount> "; 85 | std::cin >> vertex_amount; 86 | // Создание графа с заданным количеством вершин и инициализацией нулями 87 | Graph graph(vertex_amount, 0); 88 | 89 | // Ввод количества рёбер для считывания 90 | std::cout << "Input size read data> "; 91 | std::cin >> N; 92 | 93 | // Ввод данных рёбер и добавление их в граф 94 | for (int i = 0; i < N; i++) { 95 | size_t start_vertex_index, end_vertex_index; 96 | int edge_data; 97 | std::cout << "input " << i << " data (size_t start_vertex_index, size_t end_vertex_index, Data edge_data)> "; 98 | std::cin >> start_vertex_index >> end_vertex_index >> edge_data; 99 | graph.addEdge(start_vertex_index, end_vertex_index, edge_data); 100 | } 101 | 102 | // Запуск алгоритма Дейкстры для поиска кратчайших путей от заданной начальной вершины 103 | int start = 0; 104 | std::cin >> start; 105 | Vector shortest_paths = dijkstra(graph, vertex_amount, start); 106 | 107 | // Вывод результатов кратчайших путей от начальной вершины до всех остальных 108 | for (size_t i = 0; i < vertex_amount; i++) { 109 | if (shortest_paths.get(i) != INF) 110 | std::cout << "Shortest path from vertex " << start << " to vertex " << i << " is " << shortest_paths.get(i) << "\n"; 111 | else 112 | std::cout << "Shortest path from vertex " << start << " to vertex " << i << " is NULL\n"; 113 | } 114 | return 0; 115 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Algorithms 2 | 3 | [Как выполнять лабораторные работы](LABS.md) 4 | 5 | # Структура каталогов 6 | 7 | * LibraryC - шаблон для реализации библиотечных функций на языке C 8 | * LibraryCPP - шаблон для реализации библиотечных функций на языке C++ с использованием функций 9 | * LibraryCPPClass - шаблон для реализации библиотечных функций на языке C++ с использованием классов 10 | * LibraryCPPTemplate - шаблон для реализации библиотечных функций на языке C++ с использованием шаблонов 11 | * Lab1C - шаблон лабораторной работы 1, использующий библиотеку на C 12 | * Practice - задания на практику 13 | 14 | # Git 15 | 16 | * Git howto: https://githowto.com/ru 17 | * Интерактивное изучение веток в git: https://learngitbranching.js.org/?locale=ru_RU 18 | * Pro Git: https://git-scm.com/book/ru/v2 19 | 20 | ## Ошибки - это хорошо 21 | 22 | https://habr.com/ru/post/653567/ 23 | 24 | * Проверяйте код на имеющихся тестах, пишите новые 25 | * Если нашлись ошибки, просмотрите остальной код, там могут быть похожие 26 | 27 | # Материалы для изучения 28 | 29 | https://www.youtube.com/watch?v=30PzSv4ZIBU&list=PLoWGNURguz9Xk248HDiJICojc-0rlayUW 30 | 31 | https://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B_%D0%B8_%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D1%8B_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85 32 | 33 | https://www.youtube.com/c/%D0%A2%D0%B8%D0%BC%D0%BE%D1%84%D0%B5%D0%B9%D0%A5%D0%B8%D1%80%D1%8C%D1%8F%D0%BD%D0%BE%D0%B2/playlists 34 | 35 | ## Стандартная библиотека C++ 36 | 37 | http://cppstudio.com/cat/300/ 38 | 39 | ![Алгоритм выбора контейнера](containers.png) 40 | 41 | https://habr.com/ru/company/infopulse/blog/194726/ 42 | 43 | ## Время работы алгоритмов 44 | 45 | https://www.youtube.com/watch?v=pxR3UoO9c9w 46 | 47 | https://www.youtube.com/watch?v=ZRdOb4yR0kk 48 | 49 | https://habr.com/ru/company/vdsina/blog/544218/ 50 | 51 | ## Двоичный поиск 52 | 53 | https://www.youtube.com/watch?v=4c-jNoIz-uU 54 | 55 | ## Абстрактные типы данных 56 | 57 | * Массив переменного размера 58 | * Абстрактный тип данных "Стек" 59 | * Абстрактный тип данных "Очередь" 60 | 61 | https://habr.com/ru/company/infopulse/blog/238131/ 62 | 63 | https://www.youtube.com/watch?v=XlvdZCkXKL8 64 | 65 | ## Стековая арифметика. Обратная польская запись 66 | 67 | https://www.youtube.com/watch?v=sC566vzV9B0 68 | 69 | ## Динамическое программирование 70 | 71 | https://www.youtube.com/watch?v=f1w6Ac6OEsY 72 | 73 | https://www.youtube.com/watch?v=VmocLw9wwM0 74 | 75 | https://www.youtube.com/watch?v=UVAfng6OCW0 76 | 77 | https://www.youtube.com/watch?v=VgPAFaEYEo4 78 | 79 | ## Графы 80 | 81 | * Поиск в глубину 82 | * Поиск компонентов связности 83 | 84 | https://www.youtube.com/watch?v=-_E4mOMDeGs 85 | 86 | * Способы представления графов в памяти 87 | 88 | https://habr.com/ru/company/otus/blog/675730/ 89 | 90 | ## Поиск путей 91 | 92 | * Поиск в ширину 93 | * Алгоритм Дейкстры 94 | 95 | https://www.youtube.com/watch?v=intKT6COqQY 96 | 97 | * Алгоритм Беллмана-Форда 98 | * Определение наличия цикла отрицательного веса в графе 99 | * Кратчайшие пути в ациклических ориентированных графах 100 | * Кратчайшие пути между всеми парами вершин: алгоритм Флойда-Уоршолла, алгоритм Джонсона 101 | * Поиск пути на координатной сетке, волновой алгоритм 102 | 103 | https://www.youtube.com/watch?v=cca8QY3tuCI 104 | 105 | https://www.youtube.com/watch?v=9ev9Y-hJhj4 106 | 107 | ## Алгоритм A* 108 | 109 | https://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A* 110 | 111 | ## Топологическая сортировка 112 | 113 | * Поиск сильно связных компонентов 114 | 115 | https://www.youtube.com/watch?v=AYbY8fIDNz4 116 | 117 | ## Алгоритм Прима для построения минимального покрывающего дерева 118 | 119 | https://www.youtube.com/watch?v=vPHUm874EoA 120 | ## Алгоритм Крускала для построения минимального покрывающего дерева 121 | 122 | https://www.youtube.com/watch?v=94_SkpI4_V8 123 | 124 | ## Система непересекающихся множеств 125 | 126 | https://www.youtube.com/watch?v=-4M5P5af7NE 127 | 128 | ## Двоичные деревья поиска 129 | 130 | * Рандомизированное двоичное дерево поиска 131 | * АВЛ-деревья 132 | * Красно-черные деревья 133 | * Расширяющиеся деревья (splay trees) 134 | 135 | https://www.youtube.com/watch?v=RQtdVNIaH6c 136 | 137 | https://www.youtube.com/watch?v=ysbq-7IlC3M 138 | 139 | https://www.youtube.com/watch?v=RnQYXltlkrI 140 | 141 | ## Хеш-таблицы. Разрешение коллизий 142 | 143 | https://www.youtube.com/watch?v=BtBxtoXBI54 144 | 145 | https://www.youtube.com/watch?v=rVr1y32fDI0 146 | 147 | https://code-explained.com/ 148 | 149 | ## Двоичные кучи. Очередь с приоритетами 150 | 151 | https://www.youtube.com/watch?v=noQ4SUoqrQA 152 | 153 | https://www.youtube.com/watch?v=dcG0hvnRi24 154 | 155 | ## Перебор с возвратом 156 | 157 | https://www.youtube.com/watch?v=M66Tit-o6h4 158 | 159 | https://www.youtube.com/watch?v=JHzGsqPbEC8 160 | 161 | ## Жадные алгоритмы 162 | 163 | * Задача о выборе заявок 164 | * Код Хаффмена 165 | 166 | https://www.youtube.com/watch?v=RBZ8l3k9O4c 167 | 168 | https://www.youtube.com/watch?v=aFXFSTIIylU 169 | 170 | ## Сортировки 171 | 172 | * Быстрая сортировка (Хоара) 173 | * Сортировка слиянием 174 | * Сортировка с помощью кучи 175 | 176 | https://www.youtube.com/watch?v=cCLSjxrlORM 177 | 178 | https://www.youtube.com/watch?v=CKBvzscmwKs 179 | 180 | ## Поразрядная сортировка 181 | 182 | https://www.youtube.com/watch?v=JFUpuzrHB6s 183 | 184 | ## Алгоритм Кнутта-Морриса-Пратта 185 | 186 | * Задача поиска подстроки в строке 187 | * Алгоритм Карпа-Рабина 188 | * Алгоритм Кнута-Морриса-Пратта 189 | 190 | https://www.youtube.com/watch?v=kIsPv5XRJgU 191 | 192 | # Дополнительные темы 193 | 194 | https://habr.com/ru/post/455632/ 195 | 196 | https://habr.com/ru/post/664044/ 197 | 198 | https://habr.com/ru/post/673776/ 199 | 200 | ## Декартовы деревья 201 | 202 | https://www.youtube.com/watch?v=aNswE4MlVgM 203 | 204 | ## Суффиксные деревья 205 | 206 | https://www.youtube.com/watch?v=ahgv_eJDhrE 207 | 208 | ## Компактные структуры данных 209 | 210 | https://habr.com/ru/company/mailru/blog/479822/ 211 | -------------------------------------------------------------------------------- /Practice/book.tex: -------------------------------------------------------------------------------- 1 | \documentclass[10pt,twoside,openany]{book} 2 | 3 | \include{preamble} 4 | 5 | \begin{document} 6 | 7 | \include{title} 8 | \include{titleback} 9 | 10 | \tableofcontents 11 | 12 | \clearpage 13 | 14 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 15 | % Строки 16 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 17 | 18 | \chapter{Строки} 19 | 20 | \section{Изограммы} 21 | 22 | Изограмма --- это слово (или фраза), в котором не повторяются буквы. 23 | 24 | Напишите программу, которая проверяет, является ли введённая строка изограммой. 25 | Строка состоит из множества латинских букв в разном регистре, пробелов и знаков препинания. 26 | Причём в изограмме пробелы или знаки препинания могут повторяться. 27 | 28 | При реализации используйте следующие конструкции: 29 | \begin{itemize} 30 | \item Функцию {\tt std::isalpha} 31 | \item Функцию {\tt std::tolower} или {\tt std::toupper} 32 | \end{itemize} 33 | 34 | \subsection*{Контрольные вопросы} 35 | 36 | В вопросах подразумевается, что для входных данных используется кодировка ASCII. 37 | 38 | \begin{itemize} 39 | \item Какой фрагмент кода мог бы заменить функцию {\tt std::isalpha}? 40 | \item Как можно реализовать функцию {\tt std::tolower}? 41 | \end{itemize} 42 | 43 | \section{Боб} 44 | 45 | Боб не очень любит разговаривать, поэтому использует небольшой набор реплик. 46 | 47 | Он отвечает <> на любой вопрос, например <>. 48 | 49 | Он говорит <>, если вы КРИЧИТЕ НА НЕГО (то есть используете одни заглавные буквы). 50 | 51 | Он отвечает <> на вопрос, в котором вы кричите. 52 | 53 | Он говорит <> если вы обращаетесь к нему, но ничего 54 | не говорите (это значит, что входная строка программы состоит из пробельных символов). 55 | 56 | Он говорит <> во всех остальных случаях. 57 | 58 | Напишите диалоговую программу, которая имитирует разговор с Бобом. На каждую входную строку она 59 | должна выводить такой ответ, какой давал бы Боб в такой же ситуации. Входные реплики для программы 60 | должны подчиняться правилам пунктуации английского языка. 61 | 62 | \subsection*{Контрольные вопросы} 63 | 64 | \begin{itemize} 65 | \item Каким способом проверяется, что все буквы во введённой строке заглавные? 66 | \item Какую функцию стандартной библиотеки можно использовать для проверки пробельных символов? 67 | \end{itemize} 68 | 69 | \section{Шифровальный квадрат} 70 | 71 | Реализуйте описанный ниже алгоритм шифрования текста. На вход ваша программа 72 | будет получать текст на английском языке, а на выходе должна быть зашифрованная 73 | версия этого текста. 74 | 75 | При шифровании удаляются все знаки препинания и пробелы, а буквы приводятся к нижнему регистру. 76 | 77 | Затем нормализованный таким образом текст разбивается на строки. 78 | Эти строки можно выстроить в виде прямоугольника. 79 | 80 | Например, предложение <> 81 | нормализуется в виде: 82 | 83 | \begin{verbatim} 84 | ifmanwasmeanttostayonthegroundgodwouldhavegivenusroots 85 | \end{verbatim} 86 | 87 | Полученный текст перестраивается в виде прямоугольника размером в $r$~строк и $c$~столбцов, 88 | причём $c \geq r$ и $c - r \leq 1$. 89 | 90 | Таким образом, текст из примера выше должен быть преобразован в следующий прямоугольник 91 | из $8$ столбцов и $7$ строк: 92 | 93 | \begin{verbatim} 94 | "ifmanwas" 95 | "meanttos" 96 | "tayonthe" 97 | "groundgo" 98 | "dwouldha" 99 | "vegivenu" 100 | "sroots " 101 | \end{verbatim} 102 | 103 | Закодированное сообщения получается чтением сверху вниз всех столбцов от левого до правого. 104 | Для нашего примера получится следующий шифр: 105 | 106 | \begin{verbatim} 107 | imtgdvsfearwermayoogoanouuiontnnlvtwttddesaohghnsseoau 108 | \end{verbatim} 109 | 110 | Выведите полученный текст фрагментами, разделяя их пробелами. 111 | Всего должно быть $c$~фрагментов длиной $r$. 112 | Если для заполнения прямоугольника $r\times c$ не хватает $n$ символов, 113 | дополните каждый из $n$ последних фрагментов одним пробелом в конце, вот так: 114 | 115 | \begin{verbatim} 116 | "imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn sseoau " 117 | \end{verbatim} 118 | 119 | Если снова расположить эти фрагменты в прямоугольнике, их можно аналогичным образом расшифровать: 120 | 121 | \begin{verbatim} 122 | "imtgdvs" 123 | "fearwer" 124 | "mayoogo" 125 | "anouuio" 126 | "ntnnlvt" 127 | "wttddes" 128 | "aohghn " 129 | "sseoau " 130 | \end{verbatim} 131 | 132 | \subsection*{Рекомендации к заданию} 133 | 134 | При написании программы попробуйте обойтись без дополнительной структуры данных, в которой 135 | хранился бы прямоугольник. 136 | 137 | \subsection*{Контрольные вопросы} 138 | 139 | \begin{itemize} 140 | \item Какой максимальный объём текста может зашифровать ваша программа за один раз? 141 | \item Как хранится в памяти прямоугольник, который выводится на экран? 142 | \item В каком порядке обрабатываются символы нормализованной строки для вывода прямоугольника? 143 | \end{itemize} 144 | 145 | \section{Подстроки} 146 | 147 | На входе в программу поступает строка из цифр и число $n$. Программа должна вывести все 148 | непрерывные подстроки исходной строки длины $n$. 149 | 150 | Например, для строки $49142$ и $n=3$ вывод будет таким: $491$, $914$, $142$. 151 | 152 | А для $n=4$ таким: $4914$, $9142$. 153 | 154 | \subsection*{Контрольные вопросы} 155 | 156 | \begin{itemize} 157 | \item Какую стандартную функцию можно использовать для получения подстрок? 158 | \end{itemize} 159 | 160 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 161 | % array 162 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 163 | 164 | \chapter{std::array} 165 | 166 | \section{Массивы-значения} 167 | \label{array-value} 168 | 169 | Сравните две программы ниже. Предположите, какие значения выводятся в каждой из них, 170 | а затем попробуйте запустить их и проверить результат. 171 | 172 | \lstinputlisting{sources/array1.cpp} 173 | 174 | \lstinputlisting{sources/array2.cpp} 175 | 176 | \subsection*{Контрольные вопросы} 177 | 178 | \begin{itemize} 179 | \item Что выведут первая и вторая программы? 180 | \item Как можно было бы доработать вторую, чтобы получался такой же результат, как и в первой? 181 | \item Какое преимущество даёт использование {\tt std::array}? 182 | \item Что нужно изменить, чтобы не переделывать функцию {\tt sum} при изменении размера массива? 183 | \end{itemize} 184 | 185 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 186 | % vector 187 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 188 | 189 | \chapter{std::vector} 190 | 191 | \section{new[]/delete[] vs std::vector} 192 | 193 | Перепишите следующую программу, используя {\tt std::vector}. 194 | 195 | Последовательно избавьтесь от следующих конструкций: 196 | \begin{itemize} 197 | \item Операторы {\tt new[]/delete[]} (переменные {\tt a} и {\tt b} 198 | превратите в объекты {\tt std::vector}. 199 | \item Переменная {\tt m} и цикл для вычисления её значения. 200 | \end{itemize} 201 | 202 | \lstinputlisting{sources/vector1.cpp} 203 | 204 | \subsection*{Контрольные вопросы} 205 | 206 | \begin{itemize} 207 | \item Что делает исходная программа? 208 | \item Какие ограничения неявно наложены на значение переменной {\tt n}? 209 | \item На сколько строк удалось сократить исходный код, используя {\tt std::vector}? 210 | \item Когда освобождается память, используемая {\tt std::vector}? 211 | \end{itemize} 212 | 213 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 214 | % list 215 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 216 | 217 | \chapter{std::list} 218 | 219 | \section{Список вместо массива} 220 | 221 | Проанализируйте следующую программу. Попробуйте выяснить, как время её работы растёт 222 | с увеличением входного параметра $n$. 223 | 224 | \lstinputlisting{sources/list1.cpp} 225 | 226 | Перепишите программу с использованием контейнера {\tt std::list} вместо массива. 227 | Для вставки значений в список используйте функцию {\tt std::list::insert}. 228 | 229 | \subsection*{Контрольные вопросы} 230 | 231 | \begin{itemize} 232 | \item В чём заключается ошибка программиста, который написал исходную программу? 233 | \item Какими способами можно просмотреть все элементы списка, чтобы вывести их на экран? 234 | \end{itemize} 235 | 236 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 237 | % Алгоритмы 238 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 239 | 240 | \chapter{Алгоритмы} 241 | 242 | \section{std::accumulate} 243 | 244 | Переделайте функции {\tt sum} в программах из задания~\ref{array-value}, 245 | используя алгоритм {\tt std::accumulate}. 246 | Для этого потребуется подключить заголовочный файл {\tt numeric}. 247 | 248 | \subsection*{Контрольные вопросы} 249 | 250 | \begin{itemize} 251 | \item Как переделать вызов {\tt std::accumulate}, чтобы вычислялась сумма элементов 252 | из первой половины массива? 253 | \end{itemize} 254 | 255 | \section{Снова std::accumulate} 256 | 257 | Переделайте программы из предыдущего задания, чтобы вместо суммы функция {\tt std::accumulate} считала 258 | произведение элементов. 259 | 260 | \subsection*{Контрольные вопросы} 261 | 262 | \begin{itemize} 263 | \item Какое значение должно получиться, если в массиве не будет ни одного элемента? 264 | \end{itemize} 265 | 266 | \section{Сортировка} 267 | 268 | Напишите программу, которая вводит с клавиатуры последовательность чисел. Длина последовательности 269 | тоже задаётся пользователем. Затем реализуйте свой любимый алгоритм сортировки для 270 | того, чтобы упорядочить эту последовательность по возрастанию. 271 | 272 | Ваша программа не должна ограничивать длину последовательности размером используемой 273 | структуры данных для её хранения. 274 | 275 | \subsection*{Контрольные вопросы} 276 | 277 | \begin{itemize} 278 | \item Какой алгоритм сортировки вы применили? 279 | \item Можно ли этим алгоритмом отсоритировать за разумное время последовательность 280 | из $1000000$ элементов? 281 | \item Как изменить порядок сортировки в вашей программе? 282 | \end{itemize} 283 | 284 | \section{std::sort} 285 | 286 | Замените сортировку из программы для предыдущего задания на функцию {\tt std::sort} 287 | из стандартной библиотеки. Для этого понадобится заголовочный файл {\tt algorithm}. 288 | 289 | \subsection*{Контрольные вопросы} 290 | 291 | \begin{itemize} 292 | \item Какое хранилище использовалось для исходной последовательности в вашей программе? 293 | \item Как можно задать желаемый порядок элементов в результате сортировки? 294 | \end{itemize} 295 | 296 | \section{Двоичный поиск в массиве} 297 | 298 | Ещё раз доработайте предыдущую программу. Пусть она запрашивает несколько чисел, которые нужно 299 | поискать в массиве. Для каждого нужно вывести нашлось оно или нет. 300 | 301 | Сравните скорость работы вашего алгоритма поиска и стандартной функции 302 | {\tt std::binary\_search}. 303 | 304 | \subsection*{Контрольные вопросы} 305 | 306 | \begin{itemize} 307 | \item Сколько итераций цикла может выполнить двоичный поиск для массива 308 | из $10$~элементов? 309 | \end{itemize} 310 | 311 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 312 | % Структуры данных 313 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 314 | 315 | \chapter{Структуры данных} 316 | 317 | \section{Двоичное дерево} 318 | 319 | Напишите программу, которая выводит на экран графическое представление двоичного дерева. 320 | Дерево состоит из $N$ вершин, пронумерованных от $1$ до $N$. 321 | 322 | На вход программы кроме числа $N$ поступает также информация о структуре дерева 323 | в виде последовательности пар чисел, кодирующих связи. 324 | В каждой паре первое число обозначает номер предка, а второе --- номер связанного с ним потомка. 325 | 326 | Дерево нужно вывести, обозначая вершины соответствующими числами, а связи с помощью символов 327 | <<прямой слэш>> и <<обратный слэш>>. 328 | 329 | Пример вывода дерева: 330 | \begin{verbatim} 331 | 4 332 | / \ 333 | / \ 334 | 2 6 335 | / \ / \ 336 | 1 3 5 7 337 | \end{verbatim} 338 | 339 | Это дерево может быть закодировано с помощью следующих входных данных: 340 | \begin{verbatim} 341 | 7 342 | 4 2 343 | 4 6 344 | 2 1 345 | 6 5 346 | 2 3 347 | 6 7 348 | \end{verbatim} 349 | 350 | \subsection*{Контрольные вопросы} 351 | 352 | \begin{itemize} 353 | \item Что такое двоичное дерево? 354 | \item Как хранится в вашей программе двоичное дерево? 355 | \end{itemize} 356 | 357 | \section{Двоичное дерево поиска} 358 | 359 | Доработайте предыдущую программу, чтобы она проверяла, является ли дерево из входных 360 | данных двоичным деревом поиска. 361 | 362 | В двоичном дереве поиска узлы упорядочены таким образом, что значение любого левого потомка 363 | меньше, чем значение корня, а значение любого правого потомка больше, чем корень. 364 | 365 | \subsection*{Контрольные вопросы} 366 | 367 | \begin{itemize} 368 | \item Какая может быть максимальная высота двоичного дерева поиска из $N$ вершин? 369 | \end{itemize} 370 | 371 | \section{Двоичный поиск в дереве} 372 | 373 | Ещё раз доработайте программу из предыдущего задания. 374 | Теперь на вход поступают двоичное дерево поиск и последовательность чисел, которую надо в нём 375 | найти. 376 | 377 | Для каждого числа во входной последовательности выведите путь до него в двоичном дереве. 378 | 379 | \subsection*{Контрольные вопросы} 380 | 381 | \begin{itemize} 382 | \item Сохраняет ли программа в памяти путь, который будет выводиться? 383 | \end{itemize} 384 | 385 | \section{Кольцевой буфер} 386 | 387 | Реализуйте кольцевой буфер с использованием статического массива или контейнеров 388 | {\tt std::array} и {\tt std::vector}. 389 | 390 | \subsection*{Контрольные вопросы} 391 | 392 | \begin{itemize} 393 | \item Можно ли использовать все возможные ячейки в памяти, используемой под буфер? 394 | \item Какую абстрактную структуру данных можно реализовать с помощью 395 | кольцевого буфера? 396 | \end{itemize} 397 | 398 | \chapter{Хеширование} 399 | 400 | \section{Анаграммы} 401 | 402 | Анаграмма --- это слово, полученное из исходного перестановкой букв. 403 | Напишите программу, которая определяет, какие слова из списка являются анаграммами 404 | заданного слова. 405 | 406 | Например, для слова <> и списка <>, <>, <>, <> 407 | программа должна вывести список из одного элемента: <>. 408 | 409 | Предварительный отсев слов-кандидатов выполняйте с помощью вычисления 410 | хеш-функции от этих строк. 411 | 412 | \subsection*{Контрольные вопросы} 413 | 414 | \begin{itemize} 415 | \item Какую хеш-функцию вы выбрали? 416 | \item Можно ли для тех же целей использовать стандартную 417 | реализацию {\tt std::hash}? 418 | \item Что кроме хеш-функции нужно использовать, чтобы убедиться, что буквы в строках совпадают? 419 | \end{itemize} 420 | 421 | \section{Коллизии} 422 | 423 | Найти все анаграммы из слов-кандидатов для всех подмножеств букв из исходного слова. 424 | 425 | Получить подмножества букв можно несколькими способами: 426 | \begin{itemize} 427 | \item Рекурсивный перебор. На каждом шаге обрабатывается одна буква входного слова. 428 | Для каждого варианта (когда буква включается в результирующее слово и когда не включается) 429 | рекурсивный поиск продолжается со следующей буквой. 430 | \item Последовательно увеличивающиеся целые числа можно раскладывать на двоичные разряды. 431 | Каждый разряд сопоставляется одной букве. Если разряд $1$, то буква включается 432 | в результирующее подмножество. 433 | \end{itemize} 434 | 435 | Для хранения списка слов-кандидатов используйте контейнер {\tt std::unordered\_set}. 436 | Этот контейнер использует хеширование для поиска и упорядочивания элементов. 437 | Используйте второй параметр шаблона контейнера для указания собственной хеш-функции, 438 | чтобы сравнивать строки без учёта порядка букв. 439 | После генерации очередного подмножества букв можно проверять, если ли уже слово с такими 440 | буквами в контейнере. 441 | 442 | Проанализируйте, как часто возникают коллизии, если использовать только хеширование, 443 | без сложной функции сравнения строк. 444 | 445 | \subsection*{Контрольные вопросы} 446 | 447 | \begin{itemize} 448 | \item С чем связано, что строки из разных букв могут получать одни и те же значения 449 | хеш-функции? 450 | \item Приведите пример двух строк из разных букв, но с одинаковым значением хеш-функции. 451 | \end{itemize} 452 | 453 | \chapter{std::map} 454 | 455 | \section{Поиск} 456 | 457 | Перепишите следующую программу, используя {\tt std::map}. 458 | 459 | Выполните следующие действия: 460 | \begin{itemize} 461 | \item Замените массивы {\tt word} и {\tt def} на переменную-контейнер {\tt std::map}. 462 | \item Замените алгоритм поиска на функцию {\tt find} контейнера {\tt std::map}. 463 | \end{itemize} 464 | 465 | \lstinputlisting{sources/map1.cpp} 466 | 467 | \subsection*{Контрольные вопросы} 468 | 469 | \begin{itemize} 470 | \item Что делает исходная программа? 471 | \item Какой тип ключа применяется в использованном контейнере {\tt std::map}? 472 | \item Что возвращает функция {\tt find}, если нужный элемент не найден? 473 | \end{itemize} 474 | 475 | \section{Подсчёт слов} 476 | 477 | Напишите программу, которая выводит сколько раз каждое слово из входной строки повторяется в ней. 478 | 479 | Слова могут состоять из цифр и латинских букв. Слова с разным регистром букв считаются одинаковыми. 480 | Знаки препинания, пробелы, переносы строк и символы табуляции нужно игнорировать. 481 | 482 | \subsection*{Подзадачи} 483 | 484 | \begin{itemize} 485 | \item Используйте {\tt std::map} для хранения информации о количестве повторов. 486 | \item Попробуйте не считывать весь текст целиком, а читать по одному символу из входного потока. 487 | \item Напишите два варианта программы: с преобразованием хранимых в {\tt std::map} слов и без него. 488 | Для второго варианта замените функцию сравнения (третий параметр шаблона) на собственную. 489 | \end{itemize} 490 | 491 | \subsection*{Контрольные вопросы} 492 | 493 | \begin{itemize} 494 | \item Определён ли порядок элементов в {\tt std::map}? Можно ли его изменить? 495 | \end{itemize} 496 | 497 | \end{document} 498 | --------------------------------------------------------------------------------