├── .gitignore ├── For C++ ├── AVL Tree │ └── unique_AVL_tree.cpp ├── Binary Search Tree │ └── unique_binary_search_tree.cpp ├── D.Array, Stack, Queue, Deque, Pr.Queue │ ├── deque_list.cpp │ ├── dynamic_array.cpp │ ├── list_doubly.cpp │ ├── list_singly.cpp │ ├── priority_queue_list.cpp │ ├── queue_list.cpp │ └── stack_list.cpp ├── Graph │ ├── Unweighted │ │ ├── Directed │ │ │ ├── AdjList.cpp │ │ │ └── AdjMatrix.cpp │ │ └── Undirected │ │ │ ├── AdjList.cpp │ │ │ └── AdjMatrix.cpp │ └── Weighted │ │ ├── Dijkstra │ │ └── Dijkstra.cpp │ │ ├── Directed │ │ ├── AdjList.cpp │ │ └── AdjMatrix.cpp │ │ ├── Kruskal │ │ └── Kruskal.cpp │ │ └── Undirected │ │ ├── AdjList.cpp │ │ └── AdjMatrix.cpp └── Standard Template Library │ ├── PBDS.cpp │ ├── array.cpp │ ├── deque.cpp │ ├── list.cpp │ ├── map.cpp │ ├── priority_queue.cpp │ ├── queue.cpp │ ├── set.cpp │ ├── stack.cpp │ └── vector.cpp ├── For C ├── AVL Tree │ └── unique_AVL_tree.c ├── Binary Search Tree │ └── unique_binary_search_tree.c └── D.Array, Stack, Queue, Deque, Pr.Queue │ ├── deque_list.c │ ├── dynamic_array.c │ ├── list_doubly.c │ ├── list_singly.c │ ├── priority_queue_list.c │ ├── queue_array.c │ ├── queue_list.c │ ├── stack_array.c │ └── stack_list.c ├── Made by bayulaxana └── AVL Tree (Map and Set) │ ├── Map.cpp │ └── README.md └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | .vscode 2 | For C/no_upload 3 | For C/test.exe 4 | For C++/no_upload 5 | For C++/test.exe 6 | For C++ (Advanced)/no_upload 7 | For C++ (Advanced)/test.exe 8 | Miscellaneousses 9 | wiki 10 | Ans 11 | Made by bayulaxana/no_upload 12 | -------------------------------------------------------------------------------- /For C++/AVL Tree/unique_AVL_tree.cpp: -------------------------------------------------------------------------------- 1 | // ========[AVL Tree]======== // 2 | /* 3 | Dibuat dan ditulis oleh ABDUR ROCHMAN 4 | C++ conversion oleh BAYU LAKSANA 5 | 28-03-2020 6 | Struktur Data 2020 7 | For C++ 8 | */ 9 | 10 | #include 11 | #include 12 | 13 | struct AVLNode { 14 | int data; 15 | AVLNode *left, *right; 16 | int height; 17 | }; 18 | 19 | struct AVL 20 | { 21 | private: 22 | AVLNode *_root; 23 | unsigned _size; 24 | 25 | AVLNode* _avl_createNode(int value) { 26 | AVLNode *newNode = (AVLNode*) malloc(sizeof(AVLNode)); 27 | newNode->data = value; 28 | newNode->height =1; 29 | newNode->left = newNode->right = NULL; 30 | return newNode; 31 | } 32 | 33 | AVLNode* _search(AVLNode *root, int value) { 34 | while (root != NULL) { 35 | if (value < root->data) 36 | root = root->left; 37 | else if (value > root->data) 38 | root = root->right; 39 | else 40 | return root; 41 | } 42 | return root; 43 | } 44 | 45 | int _getHeight(AVLNode* node){ 46 | if(node==NULL) 47 | return 0; 48 | return node->height; 49 | } 50 | 51 | int _max(int a,int b){ 52 | return (a > b)? a : b; 53 | } 54 | 55 | AVLNode* _rightRotate(AVLNode* pivotNode){ 56 | AVLNode* newParrent=pivotNode->left; 57 | pivotNode->left=newParrent->right; 58 | newParrent->right=pivotNode; 59 | 60 | pivotNode->height=_max(_getHeight(pivotNode->left), 61 | _getHeight(pivotNode->right))+1; 62 | newParrent->height=_max(_getHeight(newParrent->left), 63 | _getHeight(newParrent->right))+1; 64 | 65 | return newParrent; 66 | } 67 | 68 | AVLNode* _leftRotate(AVLNode* pivotNode) { 69 | AVLNode* newParrent=pivotNode->right; 70 | pivotNode->right=newParrent->left; 71 | newParrent->left=pivotNode; 72 | 73 | pivotNode->height=_max(_getHeight(pivotNode->left), 74 | _getHeight(pivotNode->right))+1; 75 | newParrent->height=_max(_getHeight(newParrent->left), 76 | _getHeight(newParrent->right))+1; 77 | 78 | return newParrent; 79 | } 80 | 81 | AVLNode* _leftCaseRotate(AVLNode* node){ 82 | return _rightRotate(node); 83 | } 84 | 85 | AVLNode* _rightCaseRotate(AVLNode* node){ 86 | return _leftRotate(node); 87 | } 88 | 89 | AVLNode* _leftRightCaseRotate(AVLNode* node){ 90 | node->left=_leftRotate(node->left); 91 | return _rightRotate(node); 92 | } 93 | 94 | AVLNode* _rightLeftCaseRotate(AVLNode* node){ 95 | node->right=_rightRotate(node->right); 96 | return _leftRotate(node); 97 | } 98 | 99 | int _getBalanceFactor(AVLNode* node){ 100 | if(node==NULL) 101 | return 0; 102 | return _getHeight(node->left)-_getHeight(node->right); 103 | } 104 | 105 | AVLNode* _insert_AVL(AVLNode* node,int value) { 106 | 107 | if(node==NULL) 108 | return _avl_createNode(value); 109 | if(value < node->data) 110 | node->left = _insert_AVL(node->left,value); 111 | else if(value > node->data) 112 | node->right = _insert_AVL(node->right,value); 113 | 114 | node->height= 1 + _max(_getHeight(node->left),_getHeight(node->right)); 115 | 116 | int balanceFactor=_getBalanceFactor(node); 117 | 118 | if(balanceFactor > 1 && value < node->left->data) 119 | return _leftCaseRotate(node); 120 | if(balanceFactor > 1 && value > node->left->data) 121 | return _leftRightCaseRotate(node); 122 | if(balanceFactor < -1 && value > node->right->data) 123 | return _rightCaseRotate(node); 124 | if(balanceFactor < -1 && value < node->right->data) 125 | return _rightLeftCaseRotate(node); 126 | 127 | return node; 128 | } 129 | 130 | AVLNode* _findMinNode(AVLNode *node) { 131 | AVLNode *currNode = node; 132 | while (currNode && currNode->left != NULL) 133 | currNode = currNode->left; 134 | return currNode; 135 | } 136 | 137 | AVLNode* _remove_AVL(AVLNode* node,int value){ 138 | if(node==NULL) 139 | return node; 140 | if(value > node->data) 141 | node->right=_remove_AVL(node->right,value); 142 | else if(value < node->data) 143 | node->left=_remove_AVL(node->left,value); 144 | else{ 145 | AVLNode *temp; 146 | if((node->left==NULL)||(node->right==NULL)){ 147 | temp=NULL; 148 | if(node->left==NULL) temp=node->right; 149 | else if(node->right==NULL) temp=node->left; 150 | 151 | if(temp==NULL){ 152 | temp=node; 153 | node=NULL; 154 | } 155 | else 156 | *node=*temp; 157 | 158 | free(temp); 159 | } 160 | else{ 161 | temp = _findMinNode(node->right); 162 | node->data=temp->data; 163 | node->right=_remove_AVL(node->right,temp->data); 164 | } 165 | } 166 | 167 | if(node==NULL) return node; 168 | 169 | node->height=_max(_getHeight(node->left),_getHeight(node->right))+1; 170 | 171 | int balanceFactor= _getBalanceFactor(node); 172 | 173 | if(balanceFactor>1 && _getBalanceFactor(node->left)>=0) 174 | return _leftCaseRotate(node); 175 | 176 | if(balanceFactor>1 && _getBalanceFactor(node->left)<0) 177 | return _leftRightCaseRotate(node); 178 | 179 | if(balanceFactor<-1 && _getBalanceFactor(node->right)<=0) 180 | return _rightCaseRotate(node); 181 | 182 | if(balanceFactor<-1 && _getBalanceFactor(node->right)>0) 183 | return _rightLeftCaseRotate(node); 184 | 185 | return node; 186 | } 187 | 188 | void _inorder(AVLNode *node) { 189 | if (node) { 190 | _inorder(node->left); 191 | printf("%d ", node->data); 192 | _inorder(node->right); 193 | } 194 | } 195 | 196 | public: 197 | void init() { 198 | _root = NULL; 199 | _size = 0U; 200 | } 201 | 202 | bool isEmpty() { 203 | return _root == NULL; 204 | } 205 | 206 | bool find(int value) { 207 | AVLNode *temp = _search(_root, value); 208 | if (temp == NULL) 209 | return false; 210 | 211 | if (temp->data == value) return true; 212 | else return false; 213 | } 214 | 215 | void insert(int value) { 216 | if (!find(value)) { 217 | _root = _insert_AVL(_root, value); 218 | _size++; 219 | } 220 | } 221 | 222 | void remove(int value) { 223 | if (find(value)) { 224 | _root = _remove_AVL(_root, value); 225 | _size--; 226 | } 227 | } 228 | 229 | void inorder() { 230 | this->_inorder(_root); 231 | } 232 | }; 233 | 234 | int main(int argc, char const *argv[]) 235 | { 236 | AVL set; 237 | set.init(); 238 | 239 | set.insert(6); 240 | set.insert(611); 241 | set.insert(7); 242 | set.insert(612); 243 | set.insert(12); 244 | set.insert(4); 245 | 246 | set.inorder(); 247 | printf("\n"); 248 | 249 | set.remove(4); 250 | set.remove(612); 251 | 252 | set.inorder(); 253 | printf("\n"); 254 | return 0; 255 | } 256 | -------------------------------------------------------------------------------- /For C++/Binary Search Tree/unique_binary_search_tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi Binary Search Tree (ADT: BST) 3 | * yakni BST yang tidak menyimpan key duplikat (unique key) 4 | * 5 | * Dibuat dan ditulis oleh Bayu Laksana 6 | * -- tanggal 29 Februrari 2019 7 | * Struktur Data 2020 8 | * 9 | * Implementasi untuk Bahasa C++ 10 | */ 11 | 12 | #include 13 | #include 14 | 15 | /* Node structure */ 16 | 17 | struct BSTNode { 18 | BSTNode *left, *right; 19 | int key; 20 | }; 21 | 22 | /* uniqueBST */ 23 | 24 | struct BST { 25 | // Member 26 | BSTNode *_root; 27 | unsigned int _size; 28 | 29 | // Function 30 | void init() { 31 | _root = NULL; 32 | _size = 0u; 33 | } 34 | 35 | bool isEmpty() { 36 | return _root == NULL; 37 | } 38 | 39 | bool find(int value) { 40 | BSTNode *temp = __search(_root, value); 41 | if (!temp) 42 | return false; 43 | 44 | if (temp->key == value) 45 | return true; 46 | else 47 | return false; 48 | } 49 | 50 | void insert(int value) { 51 | if (!find(value)) { 52 | _root = __insert(_root, value); 53 | _size++; 54 | } 55 | } 56 | 57 | void remove(int value) { 58 | if (find(value)) { 59 | _root = __remove(_root, value); 60 | _size++; 61 | } 62 | } 63 | 64 | void traverseInorder() { 65 | __inorder(_root); 66 | } 67 | 68 | void traversePreorder() { 69 | __preorder(_root); 70 | } 71 | 72 | void traversePostorder() { 73 | __postorder(_root); 74 | } 75 | 76 | private: 77 | // Utility Function 78 | BSTNode* __createNode(int value) { 79 | BSTNode *newNode = (BSTNode*) malloc(sizeof(BSTNode)); 80 | newNode->key = value; 81 | newNode->left = newNode->right = NULL; 82 | return newNode; 83 | } 84 | 85 | BSTNode* __search(BSTNode *root, int value) { 86 | while (root != NULL) { 87 | if (value < root->key) 88 | root = root->left; 89 | else if (value > root->key) 90 | root = root->right; 91 | else 92 | return root; 93 | } 94 | return root; 95 | } 96 | 97 | BSTNode* __insert(BSTNode *root, int value) { 98 | if (root == NULL) 99 | return __createNode(value); 100 | 101 | if (value < root->key) 102 | root->left = __insert(root->left, value); 103 | else if (value > root->key) 104 | root->right = __insert(root->right, value); 105 | 106 | return root; 107 | } 108 | 109 | BSTNode* __findMinNode(BSTNode *node) { 110 | BSTNode *currNode = node; 111 | while (currNode && currNode->left != NULL) 112 | currNode = currNode->left; 113 | 114 | return currNode; 115 | } 116 | 117 | BSTNode* __remove(BSTNode *root, int value) { 118 | if (root == NULL) return NULL; 119 | 120 | if (value > root->key) 121 | root->right = __remove(root->right, value); 122 | else if (value < root->key) 123 | root->left = __remove(root->left, value); 124 | else { 125 | 126 | if (root->left == NULL) { 127 | BSTNode *rightChild = root->right; 128 | free(root); 129 | return rightChild; 130 | } 131 | else if (root->right == NULL) { 132 | BSTNode *leftChild = root->left; 133 | free(root); 134 | return leftChild; 135 | } 136 | 137 | BSTNode *temp = __findMinNode(root->right); 138 | root->key = temp->key; 139 | root->right = __remove(root->right, temp->key); 140 | } 141 | return root; 142 | } 143 | 144 | void __inorder(BSTNode *root) { 145 | if (root) { 146 | __inorder(root->left); 147 | printf("%d ", root->key); 148 | __inorder(root->right); 149 | } 150 | } 151 | 152 | void __postorder(BSTNode *root) { 153 | if (root) { 154 | __postorder(root->left); 155 | __postorder(root->right); 156 | printf("%d ", root->key); 157 | } 158 | } 159 | 160 | void __preorder(BSTNode *root) { 161 | if (root) { 162 | printf("%d ", root->key); 163 | __preorder(root->left); 164 | __preorder(root->right); 165 | } 166 | } 167 | }; 168 | 169 | int main(int argc, char const *argv[]) 170 | { 171 | BST set; 172 | set.init(); 173 | 174 | set.insert(6); 175 | set.insert(1); 176 | set.insert(8); 177 | set.insert(12); 178 | set.insert(1); 179 | set.insert(3); 180 | set.insert(7); 181 | 182 | set.traverseInorder(); 183 | puts(""); 184 | 185 | set.remove(1); 186 | set.remove(6); 187 | set.remove(8); 188 | set.traverseInorder(); 189 | puts(""); 190 | return 0; 191 | } 192 | -------------------------------------------------------------------------------- /For C++/D.Array, Stack, Queue, Deque, Pr.Queue/deque_list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT Deque (Double-ended Queue) 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C++ 8 | * 9 | */ 10 | 11 | #include 12 | #include 13 | 14 | using namespace std; 15 | 16 | // Node Structure 17 | struct DListNode { 18 | int data; 19 | DListNode *next, *prev; 20 | }; 21 | 22 | struct Deque 23 | { 24 | DListNode *_head, *_tail; 25 | unsigned _size; 26 | 27 | // Utility function 28 | DListNode* __createNode(int value) 29 | { 30 | DListNode *newNode = \ 31 | (DListNode*) malloc (sizeof(DListNode)); 32 | 33 | if (!newNode) return NULL; 34 | newNode->data = value; 35 | newNode->next = NULL; 36 | newNode->prev = NULL; 37 | 38 | return (DListNode*) newNode; 39 | } 40 | 41 | void init() { 42 | _head = _tail = NULL; 43 | _size = 0; 44 | } 45 | 46 | bool isEmpty() { 47 | return (_head == NULL && _tail == NULL); 48 | } 49 | 50 | void pushFront(int value) 51 | { 52 | DListNode *newNode = __createNode(value); 53 | if (newNode) { 54 | _size++; 55 | if (isEmpty()) { 56 | _head = newNode; 57 | _tail = newNode; 58 | return; 59 | } 60 | 61 | newNode->next = _head; 62 | _head->prev = newNode; 63 | _head = newNode; 64 | } 65 | } 66 | 67 | void pushBack(int value) 68 | { 69 | DListNode *newNode = __createNode(value); 70 | if (newNode) { 71 | _size++; 72 | if (isEmpty()) { 73 | _head = newNode; 74 | _tail = newNode; 75 | return; 76 | } 77 | 78 | _tail->next = newNode; 79 | newNode->prev = _tail; 80 | _tail = newNode; 81 | } 82 | } 83 | 84 | int front() 85 | { 86 | if (!isEmpty()) 87 | return _head->data; 88 | exit(-1); 89 | } 90 | 91 | int back() 92 | { 93 | if (!isEmpty()) 94 | return _tail->data; 95 | exit(-1); 96 | } 97 | 98 | void popFront() 99 | { 100 | if (!isEmpty()) { 101 | DListNode *temp = _head; 102 | if (_head == _tail) { 103 | _head = NULL; 104 | _tail = NULL; 105 | free(temp); 106 | } 107 | else { 108 | _head = _head->next; 109 | _head->prev = NULL; 110 | free(temp); 111 | } 112 | _size--; 113 | } 114 | } 115 | 116 | void popBack() 117 | { 118 | if (!isEmpty()) { 119 | DListNode *temp; 120 | if (_head == _tail) { 121 | temp = _head; 122 | _head = NULL; 123 | _tail = NULL; 124 | free(temp); 125 | } 126 | else { 127 | temp = _tail; 128 | _tail = _tail->prev; 129 | _tail->next = NULL; 130 | free(temp); 131 | } 132 | _size--; 133 | } 134 | } 135 | }; 136 | 137 | int main(int argc, char const *argv[]) 138 | { 139 | 140 | return 0; 141 | } 142 | -------------------------------------------------------------------------------- /For C++/D.Array, Stack, Queue, Deque, Pr.Queue/dynamic_array.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT Dynamic Array 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C++ 8 | * 9 | */ 10 | 11 | #include 12 | #include 13 | 14 | using namespace std; 15 | 16 | struct DynamicArray 17 | { 18 | int *_arr; 19 | unsigned int _size, _capacity; 20 | 21 | void init() { 22 | _arr = (int*) malloc(sizeof(int) * 2); 23 | _size = 0u; 24 | _capacity = 2u; 25 | } 26 | 27 | bool isEmpty() { 28 | return _size == 0; 29 | } 30 | 31 | void pushBack(int value) 32 | { 33 | if (_size + 1 > _capacity) { 34 | unsigned int it; 35 | _capacity *= 2; 36 | int *newArr = (int*) malloc(sizeof(int) * _capacity); 37 | 38 | for (it = 0; it < _size; ++it) 39 | newArr[it] = _arr[it]; 40 | 41 | int *oldArray = _arr; 42 | _arr = newArr; 43 | free(oldArray); 44 | } 45 | _arr[_size++] = value; 46 | } 47 | 48 | void setAt(unsigned index, int value) { 49 | if (!isEmpty()) { 50 | if (index >= _size) _arr[_size-1] = value; 51 | else _arr[index] = value; 52 | } 53 | else exit(-1); 54 | } 55 | 56 | void popBack() { 57 | if (!isEmpty()) _size--; 58 | else exit(-1); 59 | } 60 | 61 | int back() { 62 | if (!isEmpty()) return _arr[_size - 1]; 63 | else exit(-1); 64 | } 65 | 66 | int front() { 67 | if (!isEmpty()) return _arr[0]; 68 | else exit(-1); 69 | } 70 | 71 | int getAt(unsigned index) { 72 | if (!isEmpty()) { 73 | if (index >= _size) return _arr[_size - 1]; 74 | else return _arr[index]; 75 | } 76 | else exit(-1); 77 | } 78 | }; 79 | 80 | void printAll(DynamicArray darray) 81 | { 82 | for (int i = 0; i < darray._size; ++i) { 83 | printf("%d ", darray.getAt(i)); 84 | } 85 | printf("\n"); 86 | } 87 | 88 | int main(int argc, char const *argv[]) 89 | { 90 | // Buat objek DynamicArray 91 | DynamicArray myArray; 92 | // PENTING! Jangan lupa di-init() 93 | myArray.init(); 94 | 95 | myArray.pushBack(1); 96 | myArray.pushBack(11); 97 | myArray.pushBack(19); 98 | myArray.pushBack(23); 99 | myArray.pushBack(7); 100 | // Isi array => [1, 11, 19, 23, 7] 101 | 102 | myArray.popBack(); 103 | // Isi array => [1, 11, 19, 23] 104 | 105 | // print isi array 106 | printAll(myArray); 107 | return 0; 108 | } 109 | -------------------------------------------------------------------------------- /For C++/D.Array, Stack, Queue, Deque, Pr.Queue/list_doubly.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT List (Doubly Linked List) 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C++ 8 | * 9 | */ 10 | 11 | #include 12 | #include 13 | 14 | using namespace std; 15 | 16 | // Node Structure 17 | struct DListNode { 18 | int data; 19 | DListNode *next, *prev; 20 | }; 21 | 22 | /* Structure of Doubly Linked List */ 23 | struct List 24 | { 25 | DListNode *_head, *_tail; 26 | unsigned _size; 27 | 28 | // Utility function 29 | DListNode* __createNode(int value) 30 | { 31 | DListNode *newNode = \ 32 | (DListNode*) malloc (sizeof(DListNode)); 33 | 34 | if (!newNode) return NULL; 35 | newNode->data = value; 36 | newNode->next = NULL; 37 | newNode->prev = NULL; 38 | 39 | return (DListNode*) newNode; 40 | } 41 | 42 | void init() { 43 | _head = _tail = NULL; 44 | _size = 0; 45 | } 46 | 47 | bool isEmpty() { 48 | return (_head == NULL && _tail == NULL); 49 | } 50 | 51 | void pushFront(int value) 52 | { 53 | DListNode *newNode = __createNode(value); 54 | if (newNode) { 55 | _size++; 56 | if (isEmpty()) { 57 | _head = newNode; 58 | _tail = newNode; 59 | return; 60 | } 61 | 62 | newNode->next = _head; 63 | _head->prev = newNode; 64 | _head = newNode; 65 | } 66 | } 67 | 68 | void pushBack(int value) 69 | { 70 | DListNode *newNode = __createNode(value); 71 | if (newNode) { 72 | _size++; 73 | if (isEmpty()) { 74 | _head = newNode; 75 | _tail = newNode; 76 | return; 77 | } 78 | 79 | _tail->next = newNode; 80 | newNode->prev = _tail; 81 | _tail = newNode; 82 | } 83 | } 84 | 85 | void insertAt(unsigned index, int value) 86 | { 87 | if (index == 0) { 88 | pushFront(value); 89 | return; 90 | } 91 | else if (index >= _size) { 92 | pushBack(value); 93 | return; 94 | } 95 | 96 | DListNode *newNode = __createNode(value); 97 | if (newNode) { 98 | if (isEmpty()) { 99 | _head = newNode; 100 | _tail = newNode; 101 | _size++; 102 | return; 103 | } 104 | 105 | DListNode *temp = _head; 106 | unsigned _i = 0; 107 | 108 | while ((_i < index - 1) && \ 109 | temp->next != NULL) 110 | { 111 | temp = temp->next; 112 | _i++; 113 | } 114 | newNode->next = temp->next; 115 | newNode->prev = temp; 116 | 117 | if (temp->next) 118 | temp->next->prev = newNode; 119 | temp->next = newNode; 120 | _size++; 121 | } 122 | } 123 | 124 | int front() 125 | { 126 | if (!isEmpty()) 127 | return _head->data; 128 | exit(-1); 129 | } 130 | 131 | int back() 132 | { 133 | if (!isEmpty()) 134 | return _tail->data; 135 | exit(-1); 136 | } 137 | 138 | void popFront() 139 | { 140 | if (!isEmpty()) { 141 | DListNode *temp = _head; 142 | if (_head == _tail) { 143 | _head = NULL; 144 | _tail = NULL; 145 | free(temp); 146 | } 147 | else { 148 | _head = _head->next; 149 | _head->prev = NULL; 150 | free(temp); 151 | } 152 | _size--; 153 | } 154 | } 155 | 156 | void popBack() 157 | { 158 | if (!isEmpty()) { 159 | DListNode *temp; 160 | if (_head == _tail) { 161 | temp = _head; 162 | _head = NULL; 163 | _tail = NULL; 164 | free(temp); 165 | } 166 | else { 167 | temp = _tail; 168 | _tail = _tail->prev; 169 | _tail->next = NULL; 170 | free(temp); 171 | } 172 | _size--; 173 | } 174 | } 175 | 176 | unsigned size() { 177 | return _size; 178 | } 179 | }; 180 | 181 | int main(int argc, char const *argv[]) 182 | { 183 | // Buat objek SinglyList 184 | List myList; 185 | // PENTING! Jangan lupa di-init() 186 | myList.init(); 187 | 188 | myList.pushBack(2); 189 | myList.pushBack(3); 190 | myList.pushBack(4); 191 | myList.pushBack(5); 192 | myList.pushBack(6); 193 | // isi list => [2, 3, 4, 5, 6] 194 | 195 | myList.pushFront(9); 196 | myList.pushFront(8); 197 | myList.pushFront(7); 198 | myList.pushFront(6); 199 | // isi list => [6, 7, 8, 9, 2, 3, 4, 5, 6] 200 | 201 | myList.popFront(); 202 | myList.popBack(); 203 | myList.insertAt(2, 11); 204 | myList.insertAt(4, 17); 205 | // isi list => [7, 8, 11, 9, 17, 2, 3, 4, 5] 206 | 207 | // print list reversed 208 | while (!myList.isEmpty()) { 209 | printf("%d ", myList.back()); 210 | myList.popBack(); 211 | } 212 | printf("\n"); 213 | return 0; 214 | } -------------------------------------------------------------------------------- /For C++/D.Array, Stack, Queue, Deque, Pr.Queue/list_singly.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT SInglyList (Singly Linked List) 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C++ 8 | * 9 | */ 10 | 11 | #include 12 | #include 13 | 14 | using namespace std; 15 | 16 | // Node structure 17 | struct SListNode 18 | { 19 | int data; 20 | SListNode *next; 21 | }; 22 | 23 | /* Structure of Singly Linked List */ 24 | struct SinglyList 25 | { 26 | SListNode *_head; 27 | unsigned _size; 28 | 29 | void init() { 30 | _head = NULL; 31 | _size = 0; 32 | } 33 | 34 | bool isEmpty() { 35 | return (_head == NULL); 36 | } 37 | 38 | void pushFront(int value) 39 | { 40 | SListNode *newNode = (SListNode*) malloc(sizeof(SListNode)); 41 | if (newNode) { 42 | _size++; 43 | newNode->data = value; 44 | 45 | if (isEmpty()) newNode->next = NULL; 46 | else newNode->next = _head; 47 | _head = newNode; 48 | } 49 | } 50 | 51 | void pushBack(int value) 52 | { 53 | SListNode *newNode = (SListNode*) malloc(sizeof(SListNode)); 54 | if (newNode) { 55 | _size++; 56 | newNode->data = value; 57 | newNode->next = NULL; 58 | 59 | if (isEmpty()) 60 | _head = newNode; 61 | else { 62 | SListNode *temp = _head; 63 | while (temp->next != NULL) 64 | temp = temp->next; 65 | temp->next = newNode; 66 | } 67 | } 68 | } 69 | 70 | void popFront() 71 | { 72 | if (!isEmpty()) { 73 | SListNode *temp = _head; 74 | _head = _head->next; 75 | free(temp); 76 | _size--; 77 | } 78 | } 79 | 80 | void popBack() 81 | { 82 | if (!isEmpty()) { 83 | SListNode *nextNode = _head->next; 84 | SListNode *currNode = _head; 85 | 86 | if (currNode->next == NULL) { 87 | free(currNode); 88 | _head = NULL; 89 | return; 90 | } 91 | 92 | while (nextNode->next != NULL) { 93 | currNode = nextNode; 94 | nextNode = nextNode->next; 95 | } 96 | currNode->next = NULL; 97 | free(nextNode); 98 | _size--; 99 | } 100 | } 101 | 102 | void insertAt(int index, int value) 103 | { 104 | if (isEmpty() || index >= _size) { 105 | pushBack(value); 106 | return; 107 | } 108 | else if (index == 0) { 109 | pushFront(value); 110 | return; 111 | } 112 | 113 | SListNode *newNode = (SListNode*) malloc(sizeof(SListNode)); 114 | if (newNode) { 115 | SListNode *temp = _head; 116 | int _i = 0; 117 | 118 | while (temp->next != NULL && _i < index-1) { 119 | temp = temp->next; 120 | _i++; 121 | } 122 | newNode->data = value; 123 | newNode->next = temp->next; 124 | temp->next = newNode; 125 | _size++; 126 | } 127 | } 128 | 129 | void removeAt(int index) 130 | { 131 | if (!isEmpty()) { 132 | 133 | /* Kasus apabila posisinya melebihi batas */ 134 | if (index >= _size) { 135 | popBack(); 136 | return; 137 | } 138 | else if (index == 0 || index < 0) { 139 | popFront(); 140 | return; 141 | } 142 | 143 | SListNode *temp = _head; 144 | int _i = 0; 145 | while (temp->next != NULL && _i < index-1) { 146 | temp = temp->next; 147 | _i++; 148 | } 149 | SListNode *nextinto = temp->next->next; 150 | free(temp->next); 151 | temp->next = nextinto; 152 | _size--; 153 | } 154 | } 155 | 156 | void remove(int value) 157 | { 158 | if (!isEmpty()) { 159 | SListNode *temp, *prev; 160 | temp = _head; 161 | 162 | if (temp->data == value) { 163 | popFront(); 164 | return; 165 | } 166 | while (temp != NULL && temp->data != value) { 167 | prev = temp; 168 | temp = temp->next; 169 | } 170 | 171 | if (temp == NULL) return; 172 | prev->next = temp->next; 173 | free(temp); 174 | _size--; 175 | } 176 | } 177 | 178 | int front() { 179 | if (!isEmpty()) return _head->data; 180 | else exit(-1); 181 | } 182 | 183 | int back() 184 | { 185 | if (!isEmpty()) { 186 | SListNode *temp = _head; 187 | while (temp->next != NULL) 188 | temp = temp->next; 189 | return temp->data; 190 | } 191 | else exit(-1); 192 | } 193 | 194 | int getAt(int index) { 195 | if (!isEmpty()) { 196 | SListNode *temp = _head; 197 | int _i = 0; 198 | while (temp->next != NULL && _i < index) { 199 | temp = temp->next; 200 | _i++; 201 | } 202 | return temp->data; 203 | } 204 | else exit(-1); 205 | } 206 | }; 207 | 208 | int main(int argc, char const *argv[]) 209 | { 210 | // Buat objek SinglyList 211 | SinglyList myList; 212 | // PENTING! Jangan lupa di-init() 213 | myList.init(); 214 | 215 | myList.pushBack(2); 216 | myList.pushBack(3); 217 | myList.pushBack(4); 218 | myList.pushBack(5); 219 | myList.pushBack(6); 220 | // isi list => [2, 3, 4, 5, 6] 221 | 222 | myList.pushFront(9); 223 | myList.pushFront(8); 224 | myList.pushFront(7); 225 | myList.pushFront(6); 226 | // isi list => [6, 7, 8, 9, 2, 3, 4, 5, 6] 227 | 228 | // print isi list dari depan ke belakang 229 | for (int i = 0; i < myList._size; i++) { 230 | printf("%d ", myList.getAt(i)); 231 | } 232 | printf("\n"); 233 | 234 | myList.popFront(); 235 | myList.popBack(); 236 | myList.insertAt(2, 11); 237 | myList.insertAt(4, 17); 238 | // isi list => [7, 8, 11, 9, 17, 2, 3, 4, 5] 239 | 240 | myList.removeAt(1); 241 | myList.remove(3); 242 | // isi list => [7, 11, 9, 17, 2, 4, 5] 243 | 244 | // print list reversed 245 | while (!myList.isEmpty()) { 246 | printf("%d ", myList.back()); 247 | myList.popBack(); 248 | } 249 | printf("\n"); 250 | return 0; 251 | } -------------------------------------------------------------------------------- /For C++/D.Array, Stack, Queue, Deque, Pr.Queue/priority_queue_list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT PriorityQueue menggunakan Linked List 3 | * [default: minimum priority] 4 | * 5 | * Dibuat dan ditulis oleh Bayu Laksana 6 | * -- tanggal 22 Januari 2019 7 | * Struktur Data 2020 8 | * Implementasi untuk bahasa C++ 9 | * 10 | */ 11 | 12 | #include 13 | #include 14 | 15 | struct PQueueNode { 16 | int data; 17 | PQueueNode *next; 18 | }; 19 | 20 | // Default priority: minimum 21 | struct PriorityQueue 22 | { 23 | PQueueNode *_top; 24 | unsigned _size; 25 | 26 | void init() 27 | { 28 | _top = NULL; 29 | _size = 0; 30 | } 31 | 32 | bool isEmpty() { 33 | return (_top == NULL); 34 | } 35 | 36 | void push(int value) 37 | { 38 | PQueueNode *temp = _top; 39 | PQueueNode *newNode = \ 40 | (PQueueNode*) malloc (sizeof(PQueueNode)); 41 | newNode->data = value; 42 | newNode->next = NULL; 43 | 44 | if (isEmpty()) { 45 | _top = newNode; 46 | return; 47 | } 48 | 49 | if (value < _top->data) { 50 | newNode->next = _top; 51 | _top = newNode; 52 | } 53 | else { 54 | while ( temp->next != NULL && 55 | temp->next->data < value) 56 | temp = temp->next; 57 | newNode->next = temp->next; 58 | temp->next = newNode; 59 | } 60 | } 61 | 62 | void pop() 63 | { 64 | if (!isEmpty()) { 65 | PQueueNode *temp = _top; 66 | _top = _top->next; 67 | free(temp); 68 | } 69 | } 70 | 71 | int top() 72 | { 73 | if (!isEmpty()) return _top->data; 74 | else exit(-1); 75 | } 76 | 77 | unsigned size() { 78 | return _size; 79 | } 80 | }; 81 | 82 | int main(int argc, char const *argv[]) 83 | { 84 | 85 | return 0; 86 | } 87 | -------------------------------------------------------------------------------- /For C++/D.Array, Stack, Queue, Deque, Pr.Queue/queue_list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT Queue (Queue menggunakan Linked List) 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C++ 8 | * 9 | */ 10 | 11 | #include 12 | #include 13 | 14 | using namespace std; 15 | 16 | // Node Structure 17 | struct QueueNode { 18 | int data; 19 | QueueNode *next; 20 | }; 21 | 22 | /* Structure of Queue using List */ 23 | struct Queue 24 | { 25 | QueueNode *_front, *_rear; 26 | unsigned _size; 27 | 28 | void init() 29 | { 30 | _size = 0; 31 | _front = NULL; 32 | _rear = NULL; 33 | } 34 | 35 | bool isEmpty() { 36 | return (_front == NULL && _rear == NULL); 37 | } 38 | 39 | void push(int value) 40 | { 41 | QueueNode *newNode =\ 42 | (QueueNode*) malloc(sizeof(QueueNode)); 43 | if (newNode) { 44 | _size++; 45 | newNode->data = value; 46 | newNode->next = NULL; 47 | 48 | if (isEmpty()) 49 | _front = _rear = newNode; 50 | else { 51 | _rear->next = newNode; 52 | _rear = newNode; 53 | } 54 | } 55 | } 56 | 57 | void pop() 58 | { 59 | if (!isEmpty()) { 60 | QueueNode *temp = _front; 61 | _front = _front->next; 62 | free(temp); 63 | 64 | if (_front == NULL) 65 | _rear = NULL; 66 | _size--; 67 | } 68 | } 69 | 70 | int front() 71 | { 72 | if (!isEmpty()) 73 | return _front->data; 74 | exit(-1); 75 | } 76 | 77 | unsigned size() { 78 | return _size; 79 | } 80 | }; 81 | 82 | int main(int argc, char const *argv[]) 83 | { 84 | // Buat objek queue 85 | Queue myQueue; 86 | // PENTING!! Jangan lupa di-init() 87 | myQueue.init(); 88 | 89 | myQueue.push(23); 90 | myQueue.push(11); 91 | myQueue.push(3); 92 | myQueue.push(35); 93 | 94 | // Cetak isi queue 95 | while (!myQueue.isEmpty()) { 96 | printf("%d ", myQueue.front()); 97 | myQueue.pop(); 98 | } 99 | puts(""); 100 | return 0; 101 | } -------------------------------------------------------------------------------- /For C++/D.Array, Stack, Queue, Deque, Pr.Queue/stack_list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT Stack (Stack menggunakan Linked List) 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C++ 8 | * 9 | */ 10 | 11 | #include 12 | #include 13 | 14 | using namespace std; 15 | 16 | // Node structure 17 | struct StackNode { 18 | int data; 19 | StackNode *next; 20 | }; 21 | 22 | /* Structure of Stack using List */ 23 | struct Stack 24 | { 25 | StackNode *_top; 26 | unsigned _size; 27 | 28 | void init() 29 | { 30 | _size = 0; 31 | _top = nullptr; 32 | } 33 | 34 | bool isEmpty() { 35 | return (_top == nullptr); 36 | } 37 | 38 | void push(int value) 39 | { 40 | StackNode *newNode = (StackNode*) malloc(sizeof(StackNode)); 41 | if (newNode) { 42 | _size++; 43 | newNode->data = value; 44 | 45 | if (isEmpty()) newNode->next = NULL; 46 | else newNode->next = _top; 47 | _top = newNode; 48 | } 49 | } 50 | 51 | void pop() 52 | { 53 | if (!isEmpty()) { 54 | StackNode *temp = _top; 55 | _top = _top->next; 56 | free(temp); 57 | _size--; 58 | } 59 | } 60 | 61 | int top() 62 | { 63 | if (!isEmpty()) 64 | return _top->data; 65 | exit(-1); 66 | } 67 | }; 68 | 69 | int main(int argc, char const *argv[]) 70 | { 71 | // Buat objek stack 72 | Stack myStack; 73 | // PENTING!! Jangan lupa di-init 74 | myStack.init(); 75 | 76 | myStack.push(6); 77 | myStack.push(7); 78 | myStack.push(1); 79 | myStack.push(2); 80 | 81 | // Cetak isi stack 82 | while (!myStack.isEmpty()) { 83 | printf("%d", myStack.top()); 84 | myStack.pop(); 85 | } 86 | puts(""); 87 | return 0; 88 | } -------------------------------------------------------------------------------- /For C++/Graph/Unweighted/Directed/AdjList.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct graph{ 5 | long vertexCount, edgeCount; 6 | vector> adjList; 7 | 8 | void init(long v){ 9 | vertexCount = v; 10 | edgeCount = 0; 11 | 12 | for(int i=0; i &result, long start){ 23 | vector visited(vertexCount, false); 24 | stack st; 25 | 26 | st.push(start); 27 | visited[start] = true; 28 | result.push_back(start); 29 | 30 | while(!st.empty()){ 31 | long temp = st.top(); 32 | st.pop(); 33 | 34 | if(!visited[temp]){ 35 | result.push_back(temp); 36 | visited[temp] = true; 37 | } 38 | 39 | for(auto vertex:adjList[temp]){ 40 | if (!visited[vertex]) 41 | st.push(vertex); 42 | } 43 | } 44 | } 45 | 46 | void bfs(vector &result, long start){ 47 | vector visited(vertexCount, false); 48 | queue q; 49 | 50 | q.push(start); 51 | visited[start] = true; 52 | result.push_back(start); 53 | 54 | while(!q.empty()){ 55 | long temp = q.front(); 56 | q.pop(); 57 | 58 | for(auto vertex:adjList[temp]){ 59 | if (!visited[vertex]){ 60 | q.push(vertex); 61 | visited[vertex] = true; 62 | result.push_back(vertex); 63 | } 64 | } 65 | } 66 | } 67 | }; 68 | 69 | int main(){ 70 | graph g; 71 | g.init(5); 72 | g.add_edge(0, 1); 73 | g.add_edge(0, 2); 74 | g.add_edge(0, 3); 75 | g.add_edge(1, 3); 76 | g.add_edge(1, 4); 77 | 78 | vector dfs_result, bfs_result; 79 | g.dfs(dfs_result, 0); 80 | 81 | for(auto it:dfs_result){ 82 | cout << it << " "; 83 | } 84 | cout << endl; 85 | 86 | g.bfs(bfs_result, 0); 87 | 88 | for(auto it:bfs_result){ 89 | cout << it << " "; 90 | } 91 | cout << endl; 92 | 93 | return 0; 94 | } -------------------------------------------------------------------------------- /For C++/Graph/Unweighted/Directed/AdjMatrix.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct graph{ 5 | long vertexCount, edgeCount; 6 | vector> adjMatrix; 7 | 8 | void init(long v){ 9 | vertexCount = v; 10 | edgeCount = 0; 11 | vector zero(vertexCount, 0); 12 | 13 | for(int i=0; i &result, long start){ 24 | vector visited(vertexCount, false); 25 | stack st; 26 | 27 | st.push(start); 28 | visited[start] = true; 29 | result.push_back(start); 30 | 31 | while(!st.empty()){ 32 | long temp = st.top(); 33 | st.pop(); 34 | 35 | if(!visited[temp]){ 36 | result.push_back(temp); 37 | visited[temp] = true; 38 | } 39 | 40 | for(long i=0; i &result, long start){ 48 | vector visited(vertexCount, false); 49 | queue q; 50 | 51 | q.push(start); 52 | visited[start] = true; 53 | result.push_back(start); 54 | 55 | while(!q.empty()){ 56 | long temp = q.front(); 57 | q.pop(); 58 | 59 | for(long i=0; i dfs_result, bfs_result; 80 | g.dfs(dfs_result, 0); 81 | 82 | for(auto it:dfs_result){ 83 | cout << it << " "; 84 | } 85 | cout << endl; 86 | 87 | g.bfs(bfs_result, 0); 88 | 89 | for(auto it:bfs_result){ 90 | cout << it << " "; 91 | } 92 | cout << endl; 93 | 94 | return 0; 95 | } -------------------------------------------------------------------------------- /For C++/Graph/Unweighted/Undirected/AdjList.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct graph{ 5 | long vertexCount, edgeCount; 6 | vector> adjList; 7 | 8 | void init(long v){ 9 | vertexCount = v; 10 | edgeCount = 0; 11 | 12 | for(int i=0; i &result, long start){ 24 | vector visited(vertexCount, false); 25 | stack st; 26 | 27 | st.push(start); 28 | visited[start] = true; 29 | result.push_back(start); 30 | 31 | while(!st.empty()){ 32 | long temp = st.top(); 33 | st.pop(); 34 | 35 | if(!visited[temp]){ 36 | result.push_back(temp); 37 | visited[temp] = true; 38 | } 39 | 40 | for(auto vertex:adjList[temp]){ 41 | if (!visited[vertex]) 42 | st.push(vertex); 43 | } 44 | } 45 | } 46 | 47 | void bfs(vector &result, long start){ 48 | vector visited(vertexCount, false); 49 | queue q; 50 | 51 | q.push(start); 52 | visited[start] = true; 53 | result.push_back(start); 54 | 55 | while(!q.empty()){ 56 | long temp = q.front(); 57 | q.pop(); 58 | 59 | for(auto vertex:adjList[temp]){ 60 | if (!visited[vertex]){ 61 | q.push(vertex); 62 | visited[vertex] = true; 63 | result.push_back(vertex); 64 | } 65 | } 66 | } 67 | } 68 | }; 69 | 70 | int main(){ 71 | graph g; 72 | g.init(5); 73 | g.add_edge(0, 1); 74 | g.add_edge(0, 2); 75 | g.add_edge(0, 3); 76 | g.add_edge(1, 3); 77 | g.add_edge(1, 4); 78 | 79 | vector dfs_result, bfs_result; 80 | g.dfs(dfs_result, 0); 81 | 82 | for(auto it:dfs_result){ 83 | cout << it << " "; 84 | } 85 | cout << endl; 86 | 87 | g.bfs(bfs_result, 0); 88 | 89 | for(auto it:bfs_result){ 90 | cout << it << " "; 91 | } 92 | cout << endl; 93 | 94 | return 0; 95 | } -------------------------------------------------------------------------------- /For C++/Graph/Unweighted/Undirected/AdjMatrix.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct graph{ 5 | long vertexCount, edgeCount; 6 | vector> adjMatrix; 7 | 8 | void init(long v){ 9 | vertexCount = v; 10 | edgeCount = 0; 11 | vector zero(vertexCount, 0); 12 | 13 | for(int i=0; i &result, long start){ 25 | vector visited(vertexCount, false); 26 | stack st; 27 | 28 | st.push(start); 29 | visited[start] = true; 30 | result.push_back(start); 31 | 32 | while(!st.empty()){ 33 | long temp = st.top(); 34 | st.pop(); 35 | 36 | if(!visited[temp]){ 37 | result.push_back(temp); 38 | visited[temp] = true; 39 | } 40 | 41 | for(long i=0; i &result, long start){ 49 | vector visited(vertexCount, false); 50 | queue q; 51 | 52 | q.push(start); 53 | visited[start] = true; 54 | result.push_back(start); 55 | 56 | while(!q.empty()){ 57 | long temp = q.front(); 58 | q.pop(); 59 | 60 | for(long i=0; i dfs_result, bfs_result; 81 | g.dfs(dfs_result, 0); 82 | 83 | for(auto it:dfs_result){ 84 | cout << it << " "; 85 | } 86 | cout << endl; 87 | 88 | g.bfs(bfs_result, 0); 89 | 90 | for(auto it:bfs_result){ 91 | cout << it << " "; 92 | } 93 | cout << endl; 94 | 95 | return 0; 96 | } -------------------------------------------------------------------------------- /For C++/Graph/Weighted/Dijkstra/Dijkstra.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct graph{ 5 | long vertexCount, edgeCount; 6 | vector>> adjList; 7 | 8 | void init(long v){ 9 | vertexCount = v; 10 | edgeCount = 0; 11 | 12 | for(int i=0; i &result, long start){ 24 | vector visited(vertexCount, false); 25 | stack st; 26 | 27 | st.push(start); 28 | visited[start] = true; 29 | result.push_back(start); 30 | 31 | while(!st.empty()){ 32 | long temp = st.top(); 33 | st.pop(); 34 | 35 | if(!visited[temp]){ 36 | result.push_back(temp); 37 | visited[temp] = true; 38 | } 39 | 40 | for(auto vertex:adjList[temp]){ 41 | if (!visited[vertex.first]) 42 | st.push(vertex.first); 43 | } 44 | } 45 | } 46 | 47 | void bfs(vector &result, long start){ 48 | vector visited(vertexCount, false); 49 | queue q; 50 | 51 | q.push(start); 52 | visited[start] = true; 53 | result.push_back(start); 54 | 55 | while(!q.empty()){ 56 | long temp = q.front(); 57 | q.pop(); 58 | 59 | for(auto vertex:adjList[temp]){ 60 | if (!visited[vertex.first]){ 61 | q.push(vertex.first); 62 | visited[vertex.first] = true; 63 | result.push_back(vertex.first); 64 | } 65 | } 66 | } 67 | } 68 | 69 | void dijkstra(vector &result, long start){ 70 | vector visited(vertexCount, false); 71 | priority_queue , 72 | vector >, 73 | greater > > pq; 74 | result = vector(vertexCount, LONG_MAX); 75 | 76 | pq.push(make_pair(0, start)); 77 | result[start] = 0; 78 | 79 | while(!pq.empty()){ 80 | auto temp = pq.top(); 81 | pq.pop(); 82 | 83 | visited[temp.second] = true; 84 | 85 | for(auto vertex:adjList[temp.second]){ 86 | long nextVertex = vertex.first; 87 | long weight = vertex.second; 88 | 89 | if(!visited[nextVertex]){ 90 | if(temp.first + weight < result[nextVertex]) { 91 | result[nextVertex] = temp.first + weight; 92 | pq.push(make_pair(result[nextVertex], nextVertex)); 93 | } 94 | } 95 | } 96 | } 97 | } 98 | }; 99 | 100 | int main(){ 101 | graph g; 102 | g.init(6); 103 | g.add_edge(0, 1, 2); 104 | g.add_edge(0, 5, 4); 105 | g.add_edge(1, 3, 9); 106 | g.add_edge(5, 3, 2); 107 | g.add_edge(3, 4, 1); 108 | g.add_edge(3, 2, 5); 109 | 110 | vector dijkstra_result; 111 | 112 | g.dijkstra(dijkstra_result, 0); 113 | 114 | for(int i=0; i 2 | using namespace std; 3 | 4 | struct graph{ 5 | long vertexCount, edgeCount; 6 | vector>> adjList; 7 | 8 | void init(long v){ 9 | vertexCount = v; 10 | edgeCount = 0; 11 | 12 | for(int i=0; i &result, long start){ 23 | vector visited(vertexCount, false); 24 | stack st; 25 | 26 | st.push(start); 27 | visited[start] = true; 28 | result.push_back(start); 29 | 30 | while(!st.empty()){ 31 | long temp = st.top(); 32 | st.pop(); 33 | 34 | if(!visited[temp]){ 35 | result.push_back(temp); 36 | visited[temp] = true; 37 | } 38 | 39 | for(auto vertex:adjList[temp]){ 40 | if (!visited[vertex.first]) 41 | st.push(vertex.first); 42 | } 43 | } 44 | } 45 | 46 | void bfs(vector &result, long start){ 47 | vector visited(vertexCount, false); 48 | queue q; 49 | 50 | q.push(start); 51 | visited[start] = true; 52 | result.push_back(start); 53 | 54 | while(!q.empty()){ 55 | long temp = q.front(); 56 | q.pop(); 57 | 58 | for(auto vertex:adjList[temp]){ 59 | if (!visited[vertex.first]){ 60 | q.push(vertex.first); 61 | visited[vertex.first] = true; 62 | result.push_back(vertex.first); 63 | } 64 | } 65 | } 66 | } 67 | }; 68 | 69 | int main(){ 70 | graph g; 71 | g.init(5); 72 | g.add_edge(0, 1, 10); 73 | g.add_edge(0, 2, 20); 74 | g.add_edge(0, 3, 30); 75 | g.add_edge(1, 3, 40); 76 | g.add_edge(1, 4, 50); 77 | 78 | vector dfs_result, bfs_result; 79 | g.dfs(dfs_result, 0); 80 | 81 | for(auto it:dfs_result){ 82 | cout << it << " "; 83 | } 84 | cout << endl; 85 | 86 | g.bfs(bfs_result, 0); 87 | 88 | for(auto it:bfs_result){ 89 | cout << it << " "; 90 | } 91 | cout << endl; 92 | 93 | return 0; 94 | } -------------------------------------------------------------------------------- /For C++/Graph/Weighted/Directed/AdjMatrix.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct graph{ 5 | long vertexCount, edgeCount; 6 | vector> adjMatrix; 7 | 8 | void init(long v){ 9 | vertexCount = v; 10 | edgeCount = 0; 11 | vector zero(vertexCount, 0); 12 | 13 | for(int i=0; i &result, long start){ 24 | vector visited(vertexCount, false); 25 | stack st; 26 | 27 | st.push(start); 28 | visited[start] = true; 29 | result.push_back(start); 30 | 31 | while(!st.empty()){ 32 | long temp = st.top(); 33 | st.pop(); 34 | 35 | if(!visited[temp]){ 36 | result.push_back(temp); 37 | visited[temp] = true; 38 | } 39 | 40 | for(long i=0; i &result, long start){ 48 | vector visited(vertexCount, false); 49 | queue q; 50 | 51 | q.push(start); 52 | visited[start] = true; 53 | result.push_back(start); 54 | 55 | while(!q.empty()){ 56 | long temp = q.front(); 57 | q.pop(); 58 | 59 | for(long i=0; i dfs_result, bfs_result; 80 | g.dfs(dfs_result, 0); 81 | 82 | for(auto it:dfs_result){ 83 | cout << it << " "; 84 | } 85 | cout << endl; 86 | 87 | g.bfs(bfs_result, 0); 88 | 89 | for(auto it:bfs_result){ 90 | cout << it << " "; 91 | } 92 | cout << endl; 93 | 94 | return 0; 95 | } -------------------------------------------------------------------------------- /For C++/Graph/Weighted/Kruskal/Kruskal.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct graph 5 | { 6 | long vertexCount, edgeCount; 7 | vector>> adjList; 8 | vector>> edgeList; 9 | 10 | void init(long v) 11 | { 12 | vertexCount = v; 13 | edgeCount = 0; 14 | 15 | for (int i = 0; i < vertexCount; i++) 16 | { 17 | adjList.push_back({}); // inserts V ammount of empty vector 18 | } 19 | } 20 | 21 | void add_edge(long vertex1, long vertex2, long weight) 22 | { 23 | adjList[vertex1].push_back(make_pair(vertex2, weight)); 24 | adjList[vertex2].push_back(make_pair(vertex1, weight)); 25 | 26 | edgeList.push_back(make_pair(weight, make_pair(vertex1, vertex2))); 27 | edgeCount++; 28 | } 29 | 30 | void dfs(vector &result, long start) 31 | { 32 | vector visited(vertexCount, false); 33 | stack st; 34 | 35 | st.push(start); 36 | visited[start] = true; 37 | result.push_back(start); 38 | 39 | while (!st.empty()) 40 | { 41 | long temp = st.top(); 42 | st.pop(); 43 | 44 | if (!visited[temp]) 45 | { 46 | result.push_back(temp); 47 | visited[temp] = true; 48 | } 49 | 50 | for (auto vertex : adjList[temp]) 51 | { 52 | if (!visited[vertex.first]) 53 | st.push(vertex.first); 54 | } 55 | } 56 | } 57 | 58 | void bfs(vector &result, long start) 59 | { 60 | vector visited(vertexCount, false); 61 | queue q; 62 | 63 | q.push(start); 64 | visited[start] = true; 65 | result.push_back(start); 66 | 67 | while (!q.empty()) 68 | { 69 | long temp = q.front(); 70 | q.pop(); 71 | 72 | for (auto vertex : adjList[temp]) 73 | { 74 | if (!visited[vertex.first]) 75 | { 76 | q.push(vertex.first); 77 | visited[vertex.first] = true; 78 | result.push_back(vertex.first); 79 | } 80 | } 81 | } 82 | } 83 | 84 | void dijkstra(vector &result, long start) 85 | { 86 | vector visited(vertexCount, false); 87 | priority_queue, 88 | vector>, 89 | greater>> 90 | pq; 91 | result = vector(vertexCount, LONG_MAX); 92 | 93 | pq.push(make_pair(0, start)); 94 | result[start] = 0; 95 | 96 | while (!pq.empty()) 97 | { 98 | auto temp = pq.top(); 99 | pq.pop(); 100 | 101 | if (visited[temp.second]) 102 | continue; 103 | 104 | visited[temp.second] = true; 105 | 106 | for (auto vertex : adjList[temp.second]) 107 | { 108 | long nextVertex = vertex.first; 109 | long weight = vertex.second; 110 | 111 | if (temp.first + weight < result[nextVertex]) 112 | { 113 | result[nextVertex] = temp.first + weight; 114 | pq.push(make_pair(result[nextVertex], nextVertex)); 115 | } 116 | } 117 | } 118 | } 119 | 120 | long find_parent(vector &parent, long v) 121 | { 122 | if (v == parent[v]) 123 | return v; 124 | 125 | return parent[v] = find_parent(parent, parent[v]); 126 | } 127 | 128 | void union_set(vector &parent, long vertex1, long vertex2) 129 | { 130 | int parent1 = find_parent(parent, vertex1); 131 | int parent2 = find_parent(parent, vertex2); 132 | 133 | if (parent1 != parent2) 134 | parent[parent2] = parent1; 135 | } 136 | 137 | void kruskal(vector>> &result) 138 | { 139 | vector parent; 140 | for (int i = 0; i < vertexCount; i++) 141 | parent.push_back(i); 142 | 143 | sort(edgeList.begin(), edgeList.end()); 144 | 145 | for (auto edge : edgeList) 146 | { 147 | long vertex1 = edge.second.first; 148 | long vertex2 = edge.second.second; 149 | if (find_parent(parent, vertex1) != find_parent(parent, vertex2)) 150 | { 151 | result.push_back(edge); 152 | union_set(parent, vertex1, vertex2); 153 | if (result.size() == vertexCount - 1) 154 | return; 155 | } 156 | } 157 | } 158 | }; 159 | 160 | int main() 161 | { 162 | graph g; 163 | g.init(5); 164 | g.add_edge(0, 1, 4); 165 | g.add_edge(0, 2, 4); 166 | g.add_edge(0, 3, 6); 167 | g.add_edge(0, 4, 6); 168 | g.add_edge(1, 2, 2); 169 | g.add_edge(2, 3, 8); 170 | g.add_edge(3, 4, 9); 171 | 172 | vector>> kruskal_result; 173 | 174 | g.kruskal(kruskal_result); 175 | 176 | for (auto it : kruskal_result) 177 | { 178 | cout << it.first << " " << it.second.first << " " << it.second.second << endl; 179 | } 180 | 181 | return 0; 182 | } -------------------------------------------------------------------------------- /For C++/Graph/Weighted/Undirected/AdjList.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct graph{ 5 | long vertexCount, edgeCount; 6 | vector>> adjList; 7 | 8 | void init(long v){ 9 | vertexCount = v; 10 | edgeCount = 0; 11 | 12 | for(int i=0; i &result, long start){ 24 | vector visited(vertexCount, false); 25 | stack st; 26 | 27 | st.push(start); 28 | visited[start] = true; 29 | result.push_back(start); 30 | 31 | while(!st.empty()){ 32 | long temp = st.top(); 33 | st.pop(); 34 | 35 | if(!visited[temp]){ 36 | result.push_back(temp); 37 | visited[temp] = true; 38 | } 39 | 40 | for(auto vertex:adjList[temp]){ 41 | if (!visited[vertex.first]) 42 | st.push(vertex.first); 43 | } 44 | } 45 | } 46 | 47 | void bfs(vector &result, long start){ 48 | vector visited(vertexCount, false); 49 | queue q; 50 | 51 | q.push(start); 52 | visited[start] = true; 53 | result.push_back(start); 54 | 55 | while(!q.empty()){ 56 | long temp = q.front(); 57 | q.pop(); 58 | 59 | for(auto vertex:adjList[temp]){ 60 | if (!visited[vertex.first]){ 61 | q.push(vertex.first); 62 | visited[vertex.first] = true; 63 | result.push_back(vertex.first); 64 | } 65 | } 66 | } 67 | } 68 | }; 69 | 70 | int main(){ 71 | graph g; 72 | g.init(5); 73 | g.add_edge(0, 1, 10); 74 | g.add_edge(0, 2, 20); 75 | g.add_edge(0, 3, 30); 76 | g.add_edge(1, 3, 40); 77 | g.add_edge(1, 4, 50); 78 | 79 | vector dfs_result, bfs_result; 80 | g.dfs(dfs_result, 0); 81 | 82 | for(auto it:dfs_result){ 83 | cout << it << " "; 84 | } 85 | cout << endl; 86 | 87 | g.bfs(bfs_result, 0); 88 | 89 | for(auto it:bfs_result){ 90 | cout << it << " "; 91 | } 92 | cout << endl; 93 | 94 | return 0; 95 | } -------------------------------------------------------------------------------- /For C++/Graph/Weighted/Undirected/AdjMatrix.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct graph{ 5 | long vertexCount, edgeCount; 6 | vector> adjMatrix; 7 | 8 | void init(long v){ 9 | vertexCount = v; 10 | edgeCount = 0; 11 | vector zero(vertexCount, 0); 12 | 13 | for(int i=0; i &result, long start){ 25 | vector visited(vertexCount, false); 26 | stack st; 27 | 28 | st.push(start); 29 | visited[start] = true; 30 | result.push_back(start); 31 | 32 | while(!st.empty()){ 33 | long temp = st.top(); 34 | st.pop(); 35 | 36 | if(!visited[temp]){ 37 | result.push_back(temp); 38 | visited[temp] = true; 39 | } 40 | 41 | for(long i=0; i &result, long start){ 49 | vector visited(vertexCount, false); 50 | queue q; 51 | 52 | q.push(start); 53 | visited[start] = true; 54 | result.push_back(start); 55 | 56 | while(!q.empty()){ 57 | long temp = q.front(); 58 | q.pop(); 59 | 60 | for(long i=0; i dfs_result, bfs_result; 81 | g.dfs(dfs_result, 0); 82 | 83 | for(auto it:dfs_result){ 84 | cout << it << " "; 85 | } 86 | cout << endl; 87 | 88 | g.bfs(bfs_result, 0); 89 | 90 | for(auto it:bfs_result){ 91 | cout << it << " "; 92 | } 93 | cout << endl; 94 | 95 | return 0; 96 | } -------------------------------------------------------------------------------- /For C++/Standard Template Library/PBDS.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include //perhatikan header ini harus disertakan 3 | #include //perhatikan header ini harus disertakan 4 | 5 | using namespace std; 6 | using namespace __gnu_pbds; //struktur data ini berada pada class __gnu_pbds 7 | 8 | typedef tree< 9 | int, //bisa diganti sesuai tipe data yang dibutuhkan 10 | null_type, 11 | less, //jika ingin elemen tidak unik bisa menggunakan less_equal 12 | rb_tree_tag, 13 | tree_order_statistics_node_update> AVL; //karena namanya yang panjang, sebaiknya menggunakan typedef 14 | //menggunakan nama AVL karena memiliki fungsi-fungsi yang ada pada AVL Tree 15 | 16 | int main() 17 | { 18 | AVL X; 19 | for (int i = 1 ; i <= 10 ; i += 2) 20 | X.insert(i); 21 | 22 | cout << "elemen pada index ke 0 adalah : " << *X.find_by_order(0) << endl; 23 | cout << "elemen pada index ke 5 adalah : " << *X.find_by_order(5) << endl; 24 | 25 | cout << "jumlah elemen yang lebih kecil dari 6 sebanyak : " << X.order_of_key(6) << endl; 26 | } -------------------------------------------------------------------------------- /For C++/Standard Template Library/array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() 7 | { 8 | array angka = {1, 2, 3, 4}; 9 | array genap = {2, 4, 6, 8}; 10 | array ganjil = {1, 3, 5, 7}; 11 | array kosong; 12 | 13 | cout << "Isi array \"angka\":"; 14 | for (int i = 0; i < 4; i++) 15 | cout << ' ' << angka[i]; 16 | cout << '\n'; 17 | 18 | cout << "Elemen ke-2 (operator[]): " << angka[1] << endl; 19 | cout << "Elemen ke-2 (at()): " << angka.at(1) << endl; 20 | cout << "Elemen pertama: " << angka.front() << endl; 21 | cout << "Elemen terakhir: " << angka.back() << endl; 22 | 23 | angka.front() = 100; 24 | angka.at(1) = 200; 25 | angka.back() = 400; 26 | 27 | cout << "Isi array \"angka\" sekarang:"; 28 | for (auto i = angka.begin(); i != angka.end(); ++i) 29 | cout << ' ' << *i; 30 | cout << '\n'; 31 | 32 | cout << "Jumlah elemen pada array \"angka\": " << angka.size() << "\n"; 33 | cout << "Jumlah maksimal elemen yang dapat ditampung oleh array \"angka\": " << angka.max_size() << "\n"; 34 | 35 | if (angka.empty()) 36 | cout << "Array \"angka\" kosong.\n"; 37 | else 38 | cout << "Array \"angka\" tidak kosong.\n"; 39 | if (kosong.empty()) 40 | cout << "Array \"kosong\" kosong.\n"; 41 | else 42 | cout << "Array \"kosong\" tidak kosong.\n"; 43 | 44 | cout << "Isi array \"genap\":"; 45 | for (int i = 0; i < 4; i++) 46 | cout << ' ' << genap.at(i); 47 | cout << '\n'; 48 | 49 | cout << "Isi array \"ganjil\":"; 50 | for (int i = 0; i < 4; i++) 51 | cout << ' ' << ganjil.at(i); 52 | cout << '\n'; 53 | 54 | genap.swap(ganjil); 55 | // atau 56 | // ganjil.swap(genap); 57 | 58 | cout << "Isi array \"genap\" setelah swap:"; 59 | for (int i = 0; i < 4; i++) 60 | cout << ' ' << genap.at(i); 61 | cout << '\n'; 62 | 63 | cout << "Isi array \"ganjil\" setelah swap:"; 64 | for (int i = 0; i < 4; i++) 65 | cout << ' ' << ganjil.at(i); 66 | cout << '\n'; 67 | 68 | angka.fill(1000); 69 | kosong.fill(10); 70 | 71 | cout << "Isi array \"angka\" setelah fill:"; 72 | for (int i = 0; i < 4; i++) 73 | cout << ' ' << angka.at(i); 74 | cout << '\n'; 75 | 76 | cout << "Isi array \"kosong\" setelah fill:"; 77 | for (auto i = kosong.begin(); i != kosong.end(); ++i) 78 | cout << ' ' << *i; 79 | cout << '\n'; 80 | 81 | return 0; 82 | } -------------------------------------------------------------------------------- /For C++/Standard Template Library/deque.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | deque angka; 8 | deque genap = {2, 4, 6, 8}; 9 | deque ganjil = {1, 3, 5, 7}; 10 | 11 | angka.push_front(2); 12 | angka.push_back(3); 13 | angka.push_front(1); 14 | angka.push_back(4); 15 | 16 | cout << "Isi deque \"angka\":"; 17 | for (auto i = angka.begin(); i != angka.end(); ++i) 18 | cout << ' ' << *i; 19 | cout << '\n'; 20 | 21 | cout << "Jumlah elemen pada deque \"angka\": " << angka.size() << "\n"; 22 | cout << "Jumlah maksimal elemen yang dapat ditampung oleh deque \"angka\": " << angka.max_size() << "\n"; 23 | 24 | if (angka.empty()) 25 | cout << "Deque \"angka\" kosong.\n"; 26 | else 27 | cout << "Deque \"angka\" tidak kosong.\n"; 28 | 29 | angka.pop_front(); 30 | angka.pop_back(); 31 | 32 | cout << "Isi list \"angka\" setelah pop (front dan back):"; 33 | for (auto i = angka.begin(); i != angka.end(); ++i) 34 | cout << ' ' << *i; 35 | cout << '\n'; 36 | 37 | angka.resize(5, 100); 38 | 39 | cout << "Isi deque \"angka\" setelah resize:"; 40 | for (auto i = angka.begin(); i != angka.end(); ++i) 41 | cout << ' ' << *i; 42 | cout << '\n'; 43 | 44 | angka.assign(8, 10); 45 | 46 | cout << "Isi deque \"angka\" setelah assign:"; 47 | for (auto i = angka.begin(); i != angka.end(); ++i) 48 | cout << ' ' << *i; 49 | cout << '\n'; 50 | 51 | // memasukkan nilai 20 di posisi ke-2 52 | angka.insert(angka.begin() + 1, 20); 53 | 54 | // memasukkan nilai 30 di posisi ke-3 sebanyak 3 55 | angka.insert(angka.begin() + 2, 3, 30); 56 | 57 | cout << "Isi deque \"angka\" setelah insert:"; 58 | for (auto i = angka.begin(); i != angka.end(); ++i) 59 | cout << ' ' << *i; 60 | cout << '\n'; 61 | 62 | // menghapus elemen ke-2 63 | angka.erase(angka.begin() + 1); 64 | 65 | // menghapus elemen ke-2 hingga elemen ke-5 66 | angka.erase(angka.begin() + 1, angka.begin() + 4); 67 | 68 | cout << "Isi deque \"angka\" setelah erase:"; 69 | for (auto i = angka.begin(); i != angka.end(); ++i) 70 | cout << ' ' << *i; 71 | cout << '\n'; 72 | 73 | angka.clear(); 74 | 75 | if (angka.empty()) 76 | cout << "Deque \"angka\" kosong.\n"; 77 | else 78 | cout << "Deque \"angka\" tidak kosong.\n"; 79 | 80 | cout << "Isi deque \"genap\":"; 81 | for (auto i = genap.begin(); i != genap.end(); ++i) 82 | cout << ' ' << *i; 83 | cout << '\n'; 84 | 85 | cout << "Isi deque \"ganjil\":"; 86 | for (auto i = ganjil.begin(); i != ganjil.end(); ++i) 87 | cout << ' ' << *i; 88 | cout << '\n'; 89 | 90 | genap.swap(ganjil); 91 | // atau 92 | // ganjil.swap(genap); 93 | 94 | cout << "Isi deque \"genap\" setelah swap:"; 95 | for (int i = 0; i < 4; i++) 96 | cout << ' ' << genap.at(i); 97 | cout << '\n'; 98 | 99 | cout << "Isi deque \"ganjil\" setelah swap:"; 100 | for (int i = 0; i < 4; i++) 101 | cout << ' ' << ganjil.at(i); 102 | cout << '\n'; 103 | 104 | return 0; 105 | } -------------------------------------------------------------------------------- /For C++/Standard Template Library/list.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | bool is_small_num(const int& value) { return value < 50; } 6 | 7 | int main() 8 | { 9 | list angka; 10 | list genap = {2, 4, 6, 8}; 11 | list ganjil = {1, 3, 5, 7}; 12 | list::iterator it, it1, it2; 13 | 14 | angka.push_front(4); 15 | angka.push_back(1); 16 | angka.push_front(2); 17 | angka.push_back(3); 18 | 19 | cout << "Isi list \"angka\":"; 20 | for (auto i = angka.begin(); i != angka.end(); ++i) 21 | cout << ' ' << *i; 22 | cout << '\n'; 23 | 24 | cout << "Jumlah elemen pada list \"angka\": " << angka.size() << "\n"; 25 | cout << "Jumlah maksimal elemen yang dapat ditampung oleh list \"angka\": " << angka.max_size() << "\n"; 26 | 27 | if (angka.empty()) 28 | cout << "List \"angka\" kosong.\n"; 29 | else 30 | cout << "List \"angka\" tidak kosong.\n"; 31 | 32 | angka.reverse(); 33 | 34 | cout << "Isi list \"angka\" setelah reverse:"; 35 | for (auto i = angka.begin(); i != angka.end(); ++i) 36 | cout << ' ' << *i; 37 | cout << '\n'; 38 | 39 | angka.sort(); 40 | 41 | cout << "Isi list \"angka\" setelah sort:"; 42 | for (auto i = angka.begin(); i != angka.end(); ++i) 43 | cout << ' ' << *i; 44 | cout << '\n'; 45 | 46 | angka.pop_front(); 47 | angka.pop_back(); 48 | 49 | cout << "Isi list \"angka\" setelah pop (front dan back):"; 50 | for (auto i = angka.begin(); i != angka.end(); ++i) 51 | cout << ' ' << *i; 52 | cout << '\n'; 53 | 54 | angka.resize(5, 100); 55 | 56 | cout << "Isi list \"angka\" setelah resize:"; 57 | for (auto i = angka.begin(); i != angka.end(); ++i) 58 | cout << ' ' << *i; 59 | cout << '\n'; 60 | 61 | angka.assign(8, 10); 62 | 63 | cout << "Isi list \"angka\" setelah assign:"; 64 | for (auto i = angka.begin(); i != angka.end(); ++i) 65 | cout << ' ' << *i; 66 | cout << '\n'; 67 | 68 | it = angka.begin(); // it menunjuk posisi pertama 69 | ++it; // it menunjuk posisi ke-2 70 | 71 | // memasukkan nilai 20 di posisi ke-2 72 | angka.insert(it, 20); 73 | // it menunjuk posisi ke-3 (bergeser akibat insert elemen sebanyak 1) 74 | 75 | // memasukkan nilai 30 di posisi ke-3 sebanyak 3 76 | angka.insert(it, 3, 30); 77 | 78 | cout << "Isi list \"angka\" setelah insert:"; 79 | for (auto i = angka.begin(); i != angka.end(); ++i) 80 | cout << ' ' << *i; 81 | cout << '\n'; 82 | 83 | it1 = angka.begin(); // it1 menunjuk posisi pertama 84 | ++it1; // it1 menunjuk posisi ke-2 85 | 86 | // menghapus elemen ke-2 87 | it1 = angka.erase(it1); 88 | // it tetap menunjuk posisi ke-2 89 | 90 | it2 = angka.begin(); // it2 menunjuk posisi pertama 91 | advance(it2, 4); // menggeser it2 sebanyak 4 posisi 92 | // it2 menunjuk posisi ke-5 93 | 94 | // menghapus elemen ke-2 hingga elemen ke-5 95 | angka.erase(it1, it2); 96 | 97 | cout << "Isi list \"angka\" setelah erase:"; 98 | for (auto i = angka.begin(); i != angka.end(); ++i) 99 | cout << ' ' << *i; 100 | cout << '\n'; 101 | 102 | angka.clear(); 103 | 104 | if (angka.empty()) 105 | cout << "List \"angka\" kosong.\n"; 106 | else 107 | cout << "List \"angka\" tidak kosong.\n"; 108 | 109 | cout << "Isi list \"genap\":"; 110 | for (auto i = genap.begin(); i != genap.end(); ++i) 111 | cout << ' ' << *i; 112 | cout << '\n'; 113 | 114 | cout << "Isi list \"ganjil\":"; 115 | for (auto i = ganjil.begin(); i != ganjil.end(); ++i) 116 | cout << ' ' << *i; 117 | cout << '\n'; 118 | 119 | genap.swap(ganjil); 120 | // atau 121 | // ganjil.swap(genap); 122 | 123 | cout << "Isi list \"genap\" setelah swap:"; 124 | for (auto i = genap.begin(); i != genap.end(); ++i) 125 | cout << ' ' << *i; 126 | cout << '\n'; 127 | 128 | cout << "Isi list \"ganjil\" setelah swap:"; 129 | for (auto i = ganjil.begin(); i != ganjil.end(); ++i) 130 | cout << ' ' << *i; 131 | cout << '\n'; 132 | 133 | it = genap.begin(); // it menunjuk posisi pertama 134 | advance(it, 2); // menggeser it sebanyak 2 posisi 135 | 136 | // memindahkan semua elemen ke list lain 137 | genap.splice(it, ganjil); 138 | 139 | cout << "Isi list \"genap\" setelah splice:"; 140 | for (auto i = genap.begin(); i != genap.end(); ++i) 141 | cout << ' ' << *i; 142 | cout << '\n'; 143 | 144 | cout << "Isi list \"ganjil\" setelah splice:"; 145 | for (auto i = ganjil.begin(); i != ganjil.end(); ++i) 146 | cout << ' ' << *i; 147 | cout << '\n'; 148 | 149 | // memindahkan satu elemen ke list lain 150 | ganjil.splice(ganjil.begin(), genap, it); 151 | 152 | cout << "Isi list \"genap\" setelah splice:"; 153 | for (auto i = genap.begin(); i != genap.end(); ++i) 154 | cout << ' ' << *i; 155 | cout << '\n'; 156 | 157 | cout << "Isi list \"ganjil\" setelah splice:"; 158 | for (auto i = ganjil.begin(); i != ganjil.end(); ++i) 159 | cout << ' ' << *i; 160 | cout << '\n'; 161 | 162 | it = genap.begin(); // it menunjuk posisi pertama 163 | advance(it, 3); // menggeser it sebanyak 3 posisi 164 | 165 | // memindahkan beberapa elemen pada range tertentu ke list lain 166 | ganjil.splice(ganjil.begin(), ganjil, it, genap.end()); 167 | 168 | cout << "Isi list \"genap\" setelah splice:"; 169 | for (auto i = genap.begin(); i != genap.end(); ++i) 170 | cout << ' ' << *i; 171 | cout << '\n'; 172 | 173 | cout << "Isi list \"ganjil\" setelah splice:"; 174 | for (auto i = ganjil.begin(); i != ganjil.end(); ++i) 175 | cout << ' ' << *i; 176 | cout << '\n'; 177 | 178 | // syarat sebelum melakukan merge adalah kedua list terurut 179 | genap.sort(); 180 | ganjil.sort(); 181 | 182 | genap.merge(ganjil); 183 | // atau 184 | // ganjil.merge(genap); 185 | 186 | cout << "Isi list \"genap\" setelah merge:"; 187 | for (auto i = genap.begin(); i != genap.end(); ++i) 188 | cout << ' ' << *i; 189 | cout << '\n'; 190 | 191 | cout << "Isi list \"ganjil\" setelah merge:"; 192 | for (auto i = ganjil.begin(); i != ganjil.end(); ++i) 193 | cout << ' ' << *i; 194 | cout << '\n'; 195 | 196 | for (int i = 0; i < 10; i++) 197 | { 198 | angka.push_front((i + 1) * 10); 199 | } 200 | 201 | for (int i = 0; i < 10; i++) 202 | { 203 | angka.push_back((i + 1) * 10); 204 | } 205 | 206 | angka.sort(); 207 | 208 | cout << "Isi list \"angka\":"; 209 | for (auto i = angka.begin(); i != angka.end(); ++i) 210 | cout << ' ' << *i; 211 | cout << '\n'; 212 | 213 | angka.remove(10); 214 | 215 | cout << "Isi list \"angka\" setelah remove:"; 216 | for (auto i = angka.begin(); i != angka.end(); ++i) 217 | cout << ' ' << *i; 218 | cout << '\n'; 219 | 220 | angka.remove_if(is_small_num); 221 | 222 | cout << "Isi list \"angka\" setelah remove if:"; 223 | for (auto i = angka.begin(); i != angka.end(); ++i) 224 | cout << ' ' << *i; 225 | cout << '\n'; 226 | 227 | angka.unique(); 228 | 229 | cout << "Isi list \"angka\" setelah unique:"; 230 | for (auto i = angka.begin(); i != angka.end(); ++i) 231 | cout << ' ' << *i; 232 | cout << '\n'; 233 | 234 | return 0; 235 | } -------------------------------------------------------------------------------- /For C++/Standard Template Library/map.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | map map_int_int; //key : integer, value integer; 8 | map map_int_string; //key : integer, value string; 9 | map map_string_int; //key : string, value integer; 10 | 11 | for (int i = 1 ; i <= 5 ; i++) 12 | { 13 | map_int_int[i] = i * 5; // (key,value) = (1,5) , (2,10) , (3,15) , (4,20) , (5,25) 14 | } 15 | 16 | map_int_string[1] = "satu"; 17 | map_int_string[2] = "dua"; 18 | map_int_string[3] = "tiga"; // (key,value) = (1,"satu") , (2,"dua") , (3,"tiga") 19 | 20 | for (map::iterator it = map_int_string.begin() ; it != map_int_string.end() ; ++it) // mengiterasi semua isi dari map_int_string 21 | { 22 | pair cur = *it; 23 | map_string_int[cur.second] = cur.first; //(key,value) = ("satu",1) , ("dua",2) , ("tiga",3) 24 | } 25 | 26 | cout << "ukuran map_int_string : " << map_int_string.size() << endl; 27 | map_int_string.clear(); 28 | cout << "ukuran map_int_string setelah diclear : " << map_int_string.size() << endl; 29 | 30 | for (int i = 1 ; i <= 7 ; i++) 31 | { 32 | if (map_int_int.count(i)) 33 | cout << "elemen dengan key " << i << " ada di dalam map" << endl; 34 | else 35 | cout << "elemen dengan key " << i << " tidak ada di dalam map" << endl; 36 | } 37 | } -------------------------------------------------------------------------------- /For C++/Standard Template Library/priority_queue.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | priority_queue angka; 8 | priority_queue genap; 9 | priority_queue ganjil; 10 | 11 | angka.push(2); 12 | angka.push(4); 13 | angka.push(1); 14 | angka.push(3); 15 | 16 | cout << "Elemen pertama priority queue \"angka\": " << angka.top() << "\n"; 17 | 18 | cout << "Jumlah elemen pada priority queue \"angka\": " << angka.size() << "\n"; 19 | 20 | if (angka.empty()) 21 | cout << "priority queue \"angka\" kosong.\n"; 22 | else 23 | cout << "priority queue \"angka\" tidak kosong.\n"; 24 | 25 | angka.pop(); 26 | 27 | cout << "Elemen pertama priority queue \"angka\" setelah pop: " << angka.top() << "\n"; 28 | 29 | genap.push(4); 30 | genap.push(8); 31 | genap.push(2); 32 | genap.push(6); 33 | 34 | ganjil.push(3); 35 | ganjil.push(7); 36 | ganjil.push(1); 37 | ganjil.push(5); 38 | 39 | cout << "Elemen pertama priority queue \"genap\": " << genap.top() << "\n"; 40 | cout << "Elemen pertama priority queue \"ganjil\": " << ganjil.top() << "\n"; 41 | 42 | genap.swap(ganjil); 43 | // atau 44 | // ganjil.swap(genap); 45 | 46 | cout << "Elemen pertama priority queue \"genap\" setelah swap: " << genap.top() << "\n"; 47 | cout << "Elemen pertama priority queue \"ganjil\" setelah swap: " << ganjil.top() << "\n"; 48 | 49 | return 0; 50 | } -------------------------------------------------------------------------------- /For C++/Standard Template Library/queue.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | queue angka; 8 | queue genap; 9 | queue ganjil; 10 | 11 | for (int i = 0; i < 4; i++) 12 | { 13 | angka.push(i + 1); 14 | } 15 | 16 | cout << "Elemen pertama queue \"angka\": " << angka.front() << "\n"; 17 | cout << "Elemen terakhir queue \"angka\": " << angka.back() << "\n"; 18 | 19 | cout << "Jumlah elemen pada queue \"angka\": " << angka.size() << "\n"; 20 | 21 | if (angka.empty()) 22 | cout << "queue \"angka\" kosong.\n"; 23 | else 24 | cout << "queue \"angka\" tidak kosong.\n"; 25 | 26 | angka.pop(); 27 | 28 | cout << "Elemen pertama queue \"angka\" setelah pop: " << angka.front() << "\n"; 29 | cout << "Elemen terakhir queue \"angka\" setelah pop: " << angka.back() << "\n"; 30 | 31 | for (int i = 0; i < 4; i++) 32 | { 33 | genap.push((i + 1) * 2); 34 | } 35 | 36 | for (int i = 0; i < 4; i++) 37 | { 38 | ganjil.push((i + 1) * 2 - 1); 39 | } 40 | 41 | cout << "Elemen pertama queue \"genap\": " << genap.front() << "\n"; 42 | cout << "Elemen terakhir queue \"genap\": " << genap.back() << "\n"; 43 | 44 | cout << "Elemen pertama queue \"ganjil\": " << ganjil.front() << "\n"; 45 | cout << "Elemen terakhir queue \"ganjil\": " << ganjil.back() << "\n"; 46 | 47 | genap.swap(ganjil); 48 | // atau 49 | // ganjil.swap(genap); 50 | 51 | cout << "Elemen pertama queue \"genap\" setelah swap: " << genap.front() << "\n"; 52 | cout << "Elemen terakhir queue \"genap\" setelah swap: " << genap.back() << "\n"; 53 | 54 | cout << "Elemen pertama queue \"ganjil\" setelah swap: " << ganjil.front() << "\n"; 55 | cout << "Elemen terakhir queue \"ganjil\" setelah swap: " << ganjil.back() << "\n"; 56 | 57 | return 0; 58 | } -------------------------------------------------------------------------------- /For C++/Standard Template Library/set.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | set mySet; 8 | for (int i = 1 ; i <= 10 ; i++) 9 | { 10 | for (int j = 1 ; j <= 10 ; j++) 11 | mySet.insert(i); 12 | } 13 | 14 | cout << "ukuran set sekarang : " << mySet.size() << endl; 15 | cout << "elemen - elemen di dalam set : "; 16 | for (set::iterator it = mySet.begin() ; it != mySet.end() ; ++it) 17 | { 18 | cout << *it << " "; //coba tebak kenapa harus pakai asterisk? 19 | } 20 | cout << endl; 21 | 22 | for (int i = 7 ; i <= 12 ; i++) 23 | { 24 | if (mySet.count(i)) 25 | cout << i << " ada di dalam set" << endl; 26 | else 27 | cout << i << " tidak ada di dalam set" << endl; 28 | } 29 | 30 | set::iterator lo,hi; 31 | mySet.erase(5); //1 2 3 4 6 7 8 9 10 32 | lo = mySet.lower_bound(4); // ^ 33 | hi = mySet.upper_bound(4); // ^ 34 | } -------------------------------------------------------------------------------- /For C++/Standard Template Library/stack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | stack angka; 8 | stack genap; 9 | stack ganjil; 10 | 11 | for (int i = 0; i < 4; i++) 12 | { 13 | angka.push(i + 1); 14 | } 15 | 16 | cout << "Elemen pertama stack \"angka\": " << angka.top() << "\n"; 17 | 18 | cout << "Jumlah elemen pada stack \"angka\": " << angka.size() << "\n"; 19 | 20 | if (angka.empty()) 21 | cout << "Stack \"angka\" kosong.\n"; 22 | else 23 | cout << "Stack \"angka\" tidak kosong.\n"; 24 | 25 | angka.pop(); 26 | 27 | cout << "Elemen pertama stack \"angka\" setelah pop: " << angka.top() << "\n"; 28 | 29 | for (int i = 0; i < 4; i++) 30 | { 31 | genap.push((i + 1) * 2); 32 | } 33 | 34 | for (int i = 0; i < 4; i++) 35 | { 36 | ganjil.push((i + 1) * 2 - 1); 37 | } 38 | 39 | cout << "Elemen pertama stack \"genap\": " << genap.top() << "\n"; 40 | cout << "Elemen pertama stack \"ganjil\": " << ganjil.top() << "\n"; 41 | 42 | genap.swap(ganjil); 43 | // atau 44 | // ganjil.swap(genap); 45 | 46 | cout << "Elemen pertama stack \"genap\" setelah swap: " << genap.top() << "\n"; 47 | cout << "Elemen pertama stack \"ganjil\" setelah swap: " << ganjil.top() << "\n"; 48 | 49 | return 0; 50 | } -------------------------------------------------------------------------------- /For C++/Standard Template Library/vector.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() 7 | { 8 | vector angka; 9 | vector genap = {2, 4, 6, 8}; 10 | vector ganjil = {1, 3, 5, 7}; 11 | 12 | angka.push_back(1); 13 | angka.push_back(2); 14 | angka.push_back(3); 15 | angka.push_back(4); 16 | 17 | cout << "Isi vector \"angka\":"; 18 | for (auto i = angka.begin(); i != angka.end(); ++i) 19 | cout << ' ' << *i; 20 | cout << '\n'; 21 | 22 | cout << "Jumlah elemen pada vector \"angka\": " << angka.size() << "\n"; 23 | cout << "Jumlah maksimal elemen yang dapat ditampung oleh vector \"angka\": " << angka.max_size() << "\n"; 24 | 25 | if (angka.empty()) 26 | cout << "Vector \"angka\" kosong.\n"; 27 | else 28 | cout << "Vector \"angka\" tidak kosong.\n"; 29 | 30 | angka.pop_back(); 31 | 32 | cout << "Isi vector \"angka\" setelah pop back:"; 33 | for (auto i = angka.begin(); i != angka.end(); ++i) 34 | cout << ' ' << *i; 35 | cout << '\n'; 36 | 37 | angka.resize(5, 100); 38 | 39 | cout << "Isi vector \"angka\" setelah resize:"; 40 | for (auto i = angka.begin(); i != angka.end(); ++i) 41 | cout << ' ' << *i; 42 | cout << '\n'; 43 | 44 | angka.assign(8, 10); 45 | 46 | cout << "Isi vector \"angka\" setelah assign:"; 47 | for (auto i = angka.begin(); i != angka.end(); ++i) 48 | cout << ' ' << *i; 49 | cout << '\n'; 50 | 51 | // memasukkan nilai 20 di posisi ke-2 52 | angka.insert(angka.begin() + 1, 20); 53 | 54 | // memasukkan nilai 30 di posisi ke-3 sebanyak 3 55 | angka.insert(angka.begin() + 2, 3, 30); 56 | 57 | cout << "Isi vector \"angka\" setelah insert:"; 58 | for (auto i = angka.begin(); i != angka.end(); ++i) 59 | cout << ' ' << *i; 60 | cout << '\n'; 61 | 62 | // menghapus elemen ke-2 63 | angka.erase(angka.begin() + 1); 64 | 65 | // menghapus elemen ke-2 hingga elemen ke-5 66 | angka.erase(angka.begin() + 1, angka.begin() + 4); 67 | 68 | cout << "Isi vector \"angka\" setelah erase:"; 69 | for (auto i = angka.begin(); i != angka.end(); ++i) 70 | cout << ' ' << *i; 71 | cout << '\n'; 72 | 73 | angka.clear(); 74 | 75 | if (angka.empty()) 76 | cout << "Vector \"angka\" kosong.\n"; 77 | else 78 | cout << "Vector \"angka\" tidak kosong.\n"; 79 | 80 | cout << "Isi vector \"genap\":"; 81 | for (auto i = genap.begin(); i != genap.end(); ++i) 82 | cout << ' ' << *i; 83 | cout << '\n'; 84 | 85 | cout << "Isi vector \"ganjil\":"; 86 | for (auto i = ganjil.begin(); i != ganjil.end(); ++i) 87 | cout << ' ' << *i; 88 | cout << '\n'; 89 | 90 | genap.swap(ganjil); 91 | // atau 92 | // ganjil.swap(genap); 93 | 94 | cout << "Isi vector \"genap\" setelah swap:"; 95 | for (int i = 0; i < 4; i++) 96 | cout << ' ' << genap.at(i); 97 | cout << '\n'; 98 | 99 | cout << "Isi vector \"ganjil\" setelah swap:"; 100 | for (int i = 0; i < 4; i++) 101 | cout << ' ' << ganjil.at(i); 102 | cout << '\n'; 103 | 104 | vector toSort = {5,3,2,4,1}; 105 | vector::iterator lo,hi; 106 | 107 | sort(toSort.begin(),toSort.end()); 108 | 109 | for (int i = 0 ; i < 5 ; i++) 110 | cout << " " << toSort[i]; //1 2 3 4 5 111 | cout << endl; 112 | lo = lower_bound(toSort.begin(),toSort.end(),3);// ^ 113 | hi = upper_bound(toSort.begin(),toSort.end(),3);// ^ 114 | 115 | cout << "index lower_bound : " << (lo - toSort.begin()) << endl; 116 | cout << "index upper_bound : " << (hi - toSort.begin()) << endl; 117 | return 0; 118 | } -------------------------------------------------------------------------------- /For C/AVL Tree/unique_AVL_tree.c: -------------------------------------------------------------------------------- 1 | // ========[AVL Tree]======== // 2 | /* 3 | Dibuat dan ditulis oleh ABDUR ROCHMAN 4 | 28-03-2020 5 | Struktur Data 2020 6 | For C 7 | */ 8 | 9 | #include 10 | #include 11 | #include 12 | 13 | typedef struct AVLNode_t 14 | { 15 | int data; 16 | struct AVLNode_t *left,*right; 17 | int height; 18 | }AVLNode; 19 | 20 | typedef struct AVL_t 21 | { 22 | AVLNode *_root; 23 | unsigned int _size; 24 | }AVL; 25 | 26 | AVLNode* _avl_createNode(int value) { 27 | AVLNode *newNode = (AVLNode*) malloc(sizeof(AVLNode)); 28 | newNode->data = value; 29 | newNode->height=1; 30 | newNode->left = newNode->right = NULL; 31 | return newNode; 32 | } 33 | 34 | AVLNode* _search(AVLNode *root, int value) { 35 | while (root != NULL) { 36 | if (value < root->data) 37 | root = root->left; 38 | else if (value > root->data) 39 | root = root->right; 40 | else 41 | return root; 42 | } 43 | return root; 44 | } 45 | 46 | int _getHeight(AVLNode* node){ 47 | if(node==NULL) 48 | return 0; 49 | return node->height; 50 | } 51 | 52 | int _max(int a,int b){ 53 | return (a > b)? a : b; 54 | } 55 | 56 | AVLNode* _rightRotate(AVLNode* pivotNode) { 57 | 58 | AVLNode* newParrent=pivotNode->left; 59 | pivotNode->left=newParrent->right; 60 | newParrent->right=pivotNode; 61 | 62 | pivotNode->height=_max(_getHeight(pivotNode->left), 63 | _getHeight(pivotNode->right))+1; 64 | newParrent->height=_max(_getHeight(newParrent->left), 65 | _getHeight(newParrent->right))+1; 66 | 67 | return newParrent; 68 | } 69 | 70 | AVLNode* _leftRotate(AVLNode* pivotNode) { 71 | 72 | AVLNode* newParrent=pivotNode->right; 73 | pivotNode->right=newParrent->left; 74 | newParrent->left=pivotNode; 75 | 76 | pivotNode->height=_max(_getHeight(pivotNode->left), 77 | _getHeight(pivotNode->right))+1; 78 | newParrent->height=_max(_getHeight(newParrent->left), 79 | _getHeight(newParrent->right))+1; 80 | 81 | return newParrent; 82 | } 83 | 84 | AVLNode* _leftCaseRotate(AVLNode* node){ 85 | return _rightRotate(node); 86 | } 87 | 88 | AVLNode* _rightCaseRotate(AVLNode* node){ 89 | return _leftRotate(node); 90 | } 91 | 92 | AVLNode* _leftRightCaseRotate(AVLNode* node){ 93 | node->left=_leftRotate(node->left); 94 | return _rightRotate(node); 95 | } 96 | 97 | AVLNode* _rightLeftCaseRotate(AVLNode* node){ 98 | node->right=_rightRotate(node->right); 99 | return _leftRotate(node); 100 | } 101 | 102 | int _getBalanceFactor(AVLNode* node){ 103 | if(node==NULL) 104 | return 0; 105 | return _getHeight(node->left)-_getHeight(node->right); 106 | } 107 | 108 | AVLNode* _insert_AVL(AVL *avl,AVLNode* node,int value) { 109 | 110 | if(node==NULL) // udah mencapai leaf 111 | return _avl_createNode(value); 112 | if(value < node->data) 113 | node->left = _insert_AVL(avl,node->left,value); 114 | else if(value > node->data) 115 | node->right = _insert_AVL(avl,node->right,value); 116 | 117 | node->height= 1 + _max(_getHeight(node->left),_getHeight(node->right)); 118 | 119 | int balanceFactor=_getBalanceFactor(node); 120 | 121 | if(balanceFactor > 1 && value < node->left->data) // skewed kiri (left-left case) 122 | return _leftCaseRotate(node); 123 | if(balanceFactor > 1 && value > node->left->data) // 124 | return _leftRightCaseRotate(node); 125 | if(balanceFactor < -1 && value > node->right->data) 126 | return _rightCaseRotate(node); 127 | if(balanceFactor < -1 && value < node->right->data) 128 | return _rightLeftCaseRotate(node); 129 | 130 | return node; 131 | } 132 | 133 | AVLNode* _findMinNode(AVLNode *node) { 134 | AVLNode *currNode = node; 135 | while (currNode && currNode->left != NULL) 136 | currNode = currNode->left; 137 | return currNode; 138 | } 139 | 140 | AVLNode* _remove_AVL(AVLNode* node,int value){ 141 | if(node==NULL) 142 | return node; 143 | if(value > node->data) 144 | node->right=_remove_AVL(node->right,value); 145 | else if(value < node->data) 146 | node->left=_remove_AVL(node->left,value); 147 | else{ 148 | AVLNode *temp; 149 | if((node->left==NULL)||(node->right==NULL)){ 150 | temp=NULL; 151 | if(node->left==NULL) temp=node->right; 152 | else if(node->right==NULL) temp=node->left; 153 | 154 | if(temp==NULL){ 155 | temp=node; 156 | node=NULL; 157 | } 158 | else 159 | *node=*temp; 160 | 161 | free(temp); 162 | } 163 | else{ 164 | temp = _findMinNode(node->right); 165 | node->data=temp->data; 166 | node->right=_remove_AVL(node->right,temp->data); 167 | } 168 | } 169 | 170 | if(node==NULL) return node; 171 | 172 | node->height=_max(_getHeight(node->left),_getHeight(node->right))+1; 173 | 174 | int balanceFactor= _getBalanceFactor(node); 175 | 176 | if(balanceFactor>1 && _getBalanceFactor(node->left)>=0) 177 | return _leftCaseRotate(node); 178 | 179 | if(balanceFactor>1 && _getBalanceFactor(node->left)<0) 180 | return _leftRightCaseRotate(node); 181 | 182 | if(balanceFactor < -1 && _getBalanceFactor(node->right)<=0) 183 | return _rightCaseRotate(node); 184 | 185 | if(balanceFactor < -1 && _getBalanceFactor(node->right)>0) 186 | return _rightLeftCaseRotate(node); 187 | 188 | return node; 189 | } 190 | 191 | void avl_init(AVL *avl) { 192 | avl->_root = NULL; 193 | avl->_size = 0u; 194 | } 195 | 196 | bool avl_isEmpty(AVL *avl) { 197 | return avl->_root == NULL; 198 | } 199 | 200 | bool avl_find(AVL *avl, int value) { 201 | AVLNode *temp = _search(avl->_root, value); 202 | if (temp == NULL) 203 | return false; 204 | 205 | if (temp->data == value) 206 | return true; 207 | else 208 | return false; 209 | } 210 | 211 | void avl_insert(AVL *avl,int value){ 212 | if(!avl_find(avl,value)){ 213 | avl->_root=_insert_AVL(avl,avl->_root,value); 214 | avl->_size++; 215 | } 216 | 217 | } 218 | 219 | void avl_remove(AVL *avl,int value){ 220 | if(avl_find(avl,value)){ 221 | avl->_root=_remove_AVL(avl->_root,value); 222 | avl->_size--; 223 | } 224 | 225 | } 226 | 227 | void preorder(AVLNode *root) { 228 | if (root) { 229 | preorder(root->left); 230 | printf("%d ", root->data); 231 | preorder(root->right); 232 | } 233 | } 234 | 235 | int main(){ 236 | AVL avlku; 237 | avl_init(&avlku); 238 | avl_insert(&avlku,1); 239 | avl_insert(&avlku,2); 240 | avl_insert(&avlku,3); 241 | avl_insert(&avlku,4); 242 | avl_insert(&avlku,5); 243 | avl_insert(&avlku,7); 244 | avl_insert(&avlku,99); 245 | avl_insert(&avlku,12); 246 | avl_insert(&avlku,31); 247 | avl_remove(&avlku,1); 248 | avl_remove(&avlku,99); 249 | avl_remove(&avlku,4); 250 | avl_remove(&avlku,12); 251 | avl_remove(&avlku,31); 252 | 253 | } -------------------------------------------------------------------------------- /For C/Binary Search Tree/unique_binary_search_tree.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi Binary Search Tree (ADT: BST) 3 | * yakni BST yang tidak menyimpan key duplikat (unique key) 4 | * 5 | * Dibuat dan ditulis oleh Bayu Laksana 6 | * -- tanggal 29 Februrari 2019 7 | * Struktur Data 2020 8 | * 9 | * Implementasi untuk Bahasa C 10 | */ 11 | 12 | #include 13 | #include 14 | #include 15 | 16 | /** 17 | * Node structure and 18 | * uniqueBST structure 19 | */ 20 | 21 | typedef struct bstnode_t { 22 | int key; 23 | struct bstnode_t \ 24 | *left, *right; 25 | } BSTNode; 26 | 27 | typedef struct bst_t { 28 | BSTNode *_root; 29 | unsigned int _size; 30 | } BST; 31 | 32 | /** 33 | * !!! WARNING UTILITY FUNCTION !!! 34 | * Recognized by prefix "__bst__" 35 | * --------------------------------------------- 36 | * Note that you better never access these functions, 37 | * unless you need to modify or you know how these functions work. 38 | */ 39 | 40 | BSTNode* __bst__createNode(int value) { 41 | BSTNode *newNode = (BSTNode*) malloc(sizeof(BSTNode)); 42 | newNode->key = value; 43 | newNode->left = newNode->right = NULL; 44 | return newNode; 45 | } 46 | 47 | BSTNode* __bst__insert(BSTNode *root, int value) { 48 | if (root == NULL) 49 | return __bst__createNode(value); 50 | 51 | if (value < root->key) 52 | root->left = __bst__insert(root->left, value); 53 | else if (value > root->key) 54 | root->right = __bst__insert(root->right, value); 55 | 56 | return root; 57 | } 58 | 59 | BSTNode* __bst__search(BSTNode *root, int value) { 60 | while (root != NULL) { 61 | if (value < root->key) 62 | root = root->left; 63 | else if (value > root->key) 64 | root = root->right; 65 | else 66 | return root; 67 | } 68 | return root; 69 | } 70 | 71 | BSTNode* __bst__findMinNode(BSTNode *node) { 72 | BSTNode *currNode = node; 73 | while (currNode && currNode->left != NULL) 74 | currNode = currNode->left; 75 | 76 | return currNode; 77 | } 78 | 79 | BSTNode* __bst__remove(BSTNode *root, int value) { 80 | if (root == NULL) return NULL; 81 | 82 | if (value > root->key) 83 | root->right = __bst__remove(root->right, value); 84 | else if (value < root->key) 85 | root->left = __bst__remove(root->left, value); 86 | else { 87 | 88 | if (root->left == NULL) { 89 | BSTNode *rightChild = root->right; 90 | free(root); 91 | return rightChild; 92 | } 93 | else if (root->right == NULL) { 94 | BSTNode *leftChild = root->left; 95 | free(root); 96 | return leftChild; 97 | } 98 | 99 | BSTNode *temp = __bst__findMinNode(root->right); 100 | root->key = temp->key; 101 | root->right = __bst__remove(root->right, temp->key); 102 | } 103 | return root; 104 | } 105 | 106 | void __bst__inorder(BSTNode *root) { 107 | if (root) { 108 | __bst__inorder(root->left); 109 | printf("%d ", root->key); 110 | __bst__inorder(root->right); 111 | } 112 | } 113 | 114 | void __bst__postorder(BSTNode *root) { 115 | if (root) { 116 | __bst__postorder(root->left); 117 | __bst__postorder(root->right); 118 | printf("%d ", root->key); 119 | } 120 | } 121 | 122 | void __bst__preorder(BSTNode *root) { 123 | if (root) { 124 | printf("%d ", root->key); 125 | __bst__preorder(root->left); 126 | __bst__preorder(root->right); 127 | } 128 | } 129 | 130 | /** 131 | * PRIMARY FUNCTION 132 | * --------------------------- 133 | * Accessible and safe to use. 134 | */ 135 | 136 | void bst_init(BST *bst) { 137 | bst->_root = NULL; 138 | bst->_size = 0u; 139 | } 140 | 141 | bool bst_isEmpty(BST *bst) { 142 | return bst->_root == NULL; 143 | } 144 | 145 | bool bst_find(BST *bst, int value) { 146 | BSTNode *temp = __bst__search(bst->_root, value); 147 | if (temp == NULL) 148 | return false; 149 | 150 | if (temp->key == value) 151 | return true; 152 | else 153 | return false; 154 | } 155 | 156 | void bst_insert(BST *bst, int value) { 157 | if (!bst_find(bst, value)) { 158 | bst->_root = __bst__insert(bst->_root, value); 159 | bst->_size++; 160 | } 161 | } 162 | 163 | void bst_remove(BST *bst, int value) { 164 | if (bst_find(bst, value)) { 165 | bst->_root = __bst__remove(bst->_root, value); 166 | bst->_size--; 167 | } 168 | } 169 | 170 | /** 171 | * Binary search tree traversal 172 | * - Inorder 173 | * - Postorder 174 | * - Preorder 175 | */ 176 | 177 | void bst_inorder(BST *bst) { 178 | __bst__inorder(bst->_root); 179 | } 180 | 181 | void bst_postorder(BST *bst) { 182 | __bst__postorder(bst->_root); 183 | } 184 | 185 | void bst_preorder(BST *bst) { 186 | __bst__preorder(bst->_root); 187 | } 188 | 189 | int main() 190 | { 191 | BST set; 192 | bst_init(&set); 193 | 194 | bst_insert(&set, 6); 195 | bst_insert(&set, 1); 196 | bst_insert(&set, 8); 197 | bst_insert(&set, 12); 198 | bst_insert(&set, 1); 199 | bst_insert(&set, 3); 200 | bst_insert(&set, 7); 201 | 202 | bst_inorder(&set); 203 | puts(""); 204 | 205 | bst_remove(&set, 8); 206 | bst_remove(&set, 6); 207 | bst_inorder(&set); 208 | puts(""); 209 | 210 | return 0; 211 | } 212 | -------------------------------------------------------------------------------- /For C/D.Array, Stack, Queue, Deque, Pr.Queue/deque_list.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT Deque (Double-ended Queue) 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C 8 | * 9 | * !!NOTE!! 10 | * cara menggunakan lihat pada fungsi main() 11 | */ 12 | 13 | #include 14 | #include 15 | #include 16 | 17 | /* Struktur Node */ 18 | 19 | typedef struct dnode_t { 20 | int data; 21 | struct dnode_t \ 22 | *next, 23 | *prev; 24 | } DListNode; 25 | 26 | /* Struktur ADT Deque */ 27 | /* Implementasi didasarkan pada Doubly-Linked List */ 28 | 29 | typedef struct deque_t { 30 | DListNode \ 31 | *_head, 32 | *_tail; 33 | unsigned _size; 34 | } Deque; 35 | 36 | /* DAFTAR FUNGSI YANG TERSEDIA */ 37 | 38 | DListNode* __dlist_createNode(int value); 39 | void deq_init(Deque *deque); 40 | bool deq_isEmpty(Deque *deque); 41 | void deq_pushFront(Deque *deque, int value); 42 | void deq_pushBack(Deque *deque, int value); 43 | int deq_front(Deque *deque); 44 | int deq_back(Deque *deque); 45 | void deq_popFront(Deque *deque); 46 | void deq_popBack(Deque *deque); 47 | 48 | /* Definisi Fungsi */ 49 | 50 | DListNode* __dlist_createNode(int value) 51 | { 52 | DListNode *newNode = \ 53 | (DListNode*) malloc (sizeof(DListNode)); 54 | 55 | if (!newNode) return NULL; 56 | newNode->data = value; 57 | newNode->next = NULL; 58 | newNode->prev = NULL; 59 | 60 | return (DListNode*) newNode; 61 | } 62 | 63 | void deq_init(Deque *deque) 64 | { 65 | deque->_head = deque->_tail = NULL; 66 | deque->_size = (unsigned) 0; 67 | } 68 | 69 | bool deq_isEmpty(Deque *deque) { 70 | return (deque->_head == NULL && \ 71 | deque->_tail == NULL); 72 | } 73 | 74 | void deq_pushFront(Deque *deque, int value) 75 | { 76 | DListNode *newNode = __dlist_createNode(value); 77 | if (newNode) { 78 | deque->_size++; 79 | if (deq_isEmpty(deque)) { 80 | deque->_head = newNode; 81 | deque->_tail = newNode; 82 | return; 83 | } 84 | 85 | newNode->next = deque->_head; 86 | deque->_head->prev = newNode; 87 | deque->_head = newNode; 88 | } 89 | } 90 | 91 | void deq_pushBack(Deque *deque, int value) 92 | { 93 | DListNode *newNode = __dlist_createNode(value); 94 | if (newNode) { 95 | deque->_size++; 96 | if (deq_isEmpty(deque)) { 97 | deque->_head = newNode; 98 | deque->_tail = newNode; 99 | return; 100 | } 101 | 102 | deque->_tail->next = newNode; 103 | newNode->prev = deque->_tail; 104 | deque->_tail = newNode; 105 | } 106 | } 107 | 108 | int deq_front(Deque *deque) { 109 | if (!deq_isEmpty(deque)) { 110 | return (deque->_head->data); 111 | } 112 | return 0; 113 | } 114 | 115 | int deq_back(Deque *deque) { 116 | if (!deq_isEmpty(deque)) { 117 | return (deque->_tail->data); 118 | } 119 | return 0; 120 | } 121 | 122 | void deq_popFront(Deque *deque) 123 | { 124 | if (!deq_isEmpty(deque)) { 125 | DListNode *temp = deque->_head; 126 | if (deque->_head == deque->_tail) { 127 | deque->_head = NULL; 128 | deque->_tail = NULL; 129 | free(temp); 130 | } 131 | else { 132 | deque->_head = deque->_head->next; 133 | deque->_head->prev = NULL; 134 | free(temp); 135 | } 136 | deque->_size--; 137 | } 138 | } 139 | 140 | void deq_popBack(Deque *deque) 141 | { 142 | if (!deq_isEmpty(deque)) { 143 | DListNode *temp; 144 | if (deque->_head == deque->_tail) { 145 | temp = deque->_head; 146 | deque->_head = NULL; 147 | deque->_tail = NULL; 148 | free(temp); 149 | } 150 | else { 151 | temp = deque->_tail; 152 | deque->_tail = deque->_tail->prev; 153 | deque->_tail->next = NULL; 154 | free(temp); 155 | } 156 | deque->_size--; 157 | } 158 | } 159 | 160 | int main(int argc, char const *argv[]) 161 | { 162 | Deque mydeq; 163 | deq_init(&mydeq); 164 | 165 | deq_pushBack(&mydeq, 1); 166 | deq_pushBack(&mydeq, 12); 167 | deq_pushBack(&mydeq, 6); 168 | deq_pushBack(&mydeq, 7); 169 | deq_pushBack(&mydeq, 2); 170 | 171 | deq_pushFront(&mydeq, 11); 172 | deq_pushFront(&mydeq, 8); 173 | deq_pushFront(&mydeq, 0); 174 | 175 | deq_popBack(&mydeq); 176 | deq_popFront(&mydeq); 177 | 178 | while (!deq_isEmpty(&mydeq)) { 179 | printf("%d ", deq_front(&mydeq)); 180 | deq_popFront(&mydeq); 181 | } 182 | puts(""); 183 | return 0; 184 | } 185 | -------------------------------------------------------------------------------- /For C/D.Array, Stack, Queue, Deque, Pr.Queue/dynamic_array.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT Dynamic Array 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C 8 | * 9 | * !!NOTE!! 10 | * cara menggunakan lihat pada fungsi main() 11 | */ 12 | 13 | #include 14 | #include 15 | 16 | // Struktur ADT DynamicArray 17 | 18 | typedef struct dynamicarr_t { 19 | int *_arr; 20 | unsigned _size, _capacity; 21 | } DynamicArray; 22 | 23 | // Prototipe fungsi 24 | 25 | void dArray_init(DynamicArray *darray); 26 | bool dArray_isEmpty(DynamicArray *darray); 27 | void dArray_pushBack(DynamicArray *darray, int value); 28 | void dArray_popBack(DynamicArray *darray); 29 | int dArray_back(DynamicArray *darray); 30 | int dArray_front(DynamicArray *darray); 31 | void dArray_setAt(DynamicArray *darray, unsigned index, int value); 32 | int dArray_getAt(DynamicArray *darray, unsigned index); 33 | 34 | // Definisi fungsi 35 | 36 | void dArray_init(DynamicArray *darray) 37 | { 38 | darray->_capacity = 2u; 39 | darray->_size = 0u; 40 | darray->_arr = (int*) malloc(sizeof(int) * 2); 41 | } 42 | 43 | bool dArray_isEmpty(DynamicArray *darray) { 44 | return (darray->_size == 0); 45 | } 46 | 47 | void dArray_pushBack(DynamicArray *darray, int value) 48 | { 49 | if (darray->_size + 1 > darray->_capacity) { 50 | unsigned it; 51 | darray->_capacity *= 2; 52 | int *newArr = (int*) malloc(sizeof(int) * darray->_capacity); 53 | 54 | for (it=0; it < darray->_size; ++it) 55 | newArr[it] = darray->_arr[it]; 56 | 57 | int *oldArray = darray->_arr; 58 | darray->_arr = newArr; 59 | free(oldArray); 60 | } 61 | darray->_arr[darray->_size++] = value; 62 | } 63 | 64 | void dArray_popBack(DynamicArray *darray) { 65 | if (!dArray_isEmpty(darray)) darray->_size--; 66 | else return; 67 | } 68 | 69 | int dArray_back(DynamicArray *darray) { 70 | if (!dArray_isEmpty(darray)) 71 | return darray->_arr[darray->_size-1]; 72 | else return 0; 73 | } 74 | 75 | int dArray_front(DynamicArray *darray) { 76 | if (!dArray_isEmpty(darray)) 77 | return darray->_arr[0]; 78 | else return 0; 79 | } 80 | 81 | void dArray_setAt( 82 | DynamicArray *darray, unsigned index, int value) 83 | { 84 | if (!dArray_isEmpty(darray)) { 85 | if (index >= darray->_size) 86 | darray->_arr[darray->_size-1] = value; 87 | else 88 | darray->_arr[index] = value; 89 | } 90 | } 91 | 92 | int dArray_getAt(DynamicArray *darray, unsigned index) 93 | { 94 | if (!dArray_isEmpty(darray)) { 95 | if (index >= darray->_size) 96 | return darray->_arr[darray->_size-1]; 97 | else 98 | return darray->_arr[index]; 99 | } 100 | } 101 | 102 | /* Gunakan ini untuk mempersingkat penulisan kode */ 103 | 104 | #define d_init dArray_init 105 | #define d_isEmpty dArray_isEmpty 106 | #define d_pushBack dArray_pushBack 107 | #define d_popBack dArray_popBack 108 | #define d_back dArray_back 109 | #define d_front dArray_front 110 | #define d_setAt dArray_setAt 111 | #define d_getAt dArray_getAt 112 | 113 | /* */ 114 | 115 | #include 116 | 117 | int main(int argc, char const *argv[]) 118 | { 119 | // Buat objek DynamicArray 120 | DynamicArray myArray; 121 | 122 | // PENTING! Jangan lupa diinisialisasi 123 | dArray_init(&myArray); 124 | 125 | // Operasi-operasi 126 | // myArray => [11, 14, 17, 23] 127 | dArray_pushBack(&myArray, 11); 128 | dArray_pushBack(&myArray, 14); 129 | dArray_pushBack(&myArray, 17); 130 | dArray_pushBack(&myArray, 23); 131 | 132 | // isi myArray => [11, 14, 17] 133 | dArray_popBack(&myArray); 134 | 135 | int i = 0; 136 | for (; i < myArray._size; ++i) { 137 | printf("%d ", dArray_getAt(&myArray, i)); 138 | } 139 | 140 | printf("\n"); 141 | while (!dArray_isEmpty(&myArray)) { 142 | printf("%d ", dArray_back(&myArray)); 143 | dArray_popBack(&myArray); 144 | } 145 | printf("\n"); 146 | 147 | return 0; 148 | } 149 | -------------------------------------------------------------------------------- /For C/D.Array, Stack, Queue, Deque, Pr.Queue/list_doubly.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT List (Doubly Linked List) 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C 8 | * 9 | * !!NOTE!! 10 | * cara menggunakan lihat pada fungsi main() 11 | */ 12 | 13 | #include 14 | #include 15 | 16 | /* Struktur Node */ 17 | 18 | typedef struct dnode_t { 19 | int data; 20 | struct dnode_t \ 21 | *next, 22 | *prev; 23 | } DListNode; 24 | 25 | /* Struktur ADT List */ 26 | 27 | typedef struct dlist_t { 28 | DListNode \ 29 | *_head, 30 | *_tail; 31 | unsigned _size; 32 | } List; 33 | 34 | /* DAFTAR FUNGSI YANG TERSEDIA */ 35 | 36 | DListNode* __dlist_createNode(int value); 37 | void dlist_init(List *list); 38 | bool dlist_isEmpty(List *list); 39 | void dlist_pushFront(List *list, int value); 40 | void dlist_pushBack(List *list, int value); 41 | void dlist_insertAt(List *list, unsigned index, int value); 42 | int dlist_front(List *list); 43 | int dlist_back(List *list); 44 | void dlist_popFront(List *list); 45 | void dlist_popBack(List *list); 46 | // void dlist_remove(List *list, int element); 47 | // void dlist_removeAt(List *list, int index); 48 | 49 | /* Function definition */ 50 | 51 | DListNode* __dlist_createNode(int value) 52 | { 53 | DListNode *newNode = \ 54 | (DListNode*) malloc (sizeof(DListNode)); 55 | 56 | if (!newNode) return NULL; 57 | newNode->data = value; 58 | newNode->next = NULL; 59 | newNode->prev = NULL; 60 | 61 | return (DListNode*) newNode; 62 | } 63 | 64 | void dlist_init(List *list) 65 | { 66 | list->_head = list->_tail = NULL; 67 | list->_size = (unsigned) 0; 68 | } 69 | 70 | bool dlist_isEmpty(List *list) { 71 | return (list->_head == NULL && \ 72 | list->_tail == NULL); 73 | } 74 | 75 | void dlist_pushFront(List *list, int value) 76 | { 77 | DListNode *newNode = __dlist_createNode(value); 78 | if (newNode) { 79 | list->_size++; 80 | if (dlist_isEmpty(list)) { 81 | list->_head = newNode; 82 | list->_tail = newNode; 83 | return; 84 | } 85 | 86 | newNode->next = list->_head; 87 | list->_head->prev = newNode; 88 | list->_head = newNode; 89 | } 90 | } 91 | 92 | void dlist_pushBack(List *list, int value) 93 | { 94 | DListNode *newNode = __dlist_createNode(value); 95 | if (newNode) { 96 | list->_size++; 97 | if (dlist_isEmpty(list)) { 98 | list->_head = newNode; 99 | list->_tail = newNode; 100 | return; 101 | } 102 | 103 | list->_tail->next = newNode; 104 | newNode->prev = list->_tail; 105 | list->_tail = newNode; 106 | } 107 | } 108 | 109 | void dlist_insertAt(List *list, unsigned index, int value) 110 | { 111 | if (index == 0) { 112 | dlist_pushFront(list, value); 113 | return; 114 | } 115 | else if (index >= list->_size) { 116 | dlist_pushBack(list, value); 117 | return; 118 | } 119 | 120 | DListNode *newNode = __dlist_createNode(value); 121 | if (newNode) { 122 | if (dlist_isEmpty(list)) { 123 | list->_head = newNode; 124 | list->_tail = newNode; 125 | return; 126 | } 127 | 128 | DListNode *temp = list->_head; 129 | 130 | unsigned _i = 0; 131 | while (_i < index - 1 && temp->next != NULL) { 132 | temp = temp->next; 133 | _i++; 134 | } 135 | newNode->next = temp->next; 136 | newNode->prev = temp; 137 | 138 | if (temp->next) 139 | temp->next->prev = newNode; 140 | temp->next = newNode; 141 | list->_size++; 142 | } 143 | } 144 | 145 | int dlist_front(List *list) { 146 | if (!dlist_isEmpty(list)) { 147 | return (list->_head->data); 148 | } 149 | return 0; 150 | } 151 | 152 | int dlist_back(List *list) { 153 | if (!dlist_isEmpty(list)) { 154 | return (list->_tail->data); 155 | } 156 | return 0; 157 | } 158 | 159 | void dlist_popFront(List *list) 160 | { 161 | if (!dlist_isEmpty(list)) { 162 | DListNode *temp = list->_head; 163 | if (list->_head == list->_tail) { 164 | list->_head = NULL; 165 | list->_tail = NULL; 166 | free(temp); 167 | } 168 | else { 169 | list->_head = list->_head->next; 170 | list->_head->prev = NULL; 171 | free(temp); 172 | } 173 | list->_size--; 174 | } 175 | } 176 | 177 | void dlist_popBack(List *list) 178 | { 179 | if (!dlist_isEmpty(list)) { 180 | DListNode *temp; 181 | if (list->_head == list->_tail) { 182 | temp = list->_head; 183 | list->_head = NULL; 184 | list->_tail = NULL; 185 | free(temp); 186 | } 187 | else { 188 | temp = list->_tail; 189 | list->_tail = list->_tail->prev; 190 | list->_tail->next = NULL; 191 | free(temp); 192 | } 193 | list->_size--; 194 | } 195 | } 196 | 197 | #include 198 | 199 | int main(int argc, char const *argv[]) 200 | { 201 | // Buat objek List 202 | List myList; 203 | 204 | // PENTING! Jangan lupa diinisialisasi 205 | dlist_init(&myList); 206 | 207 | // Gunakan operasi linked list 208 | dlist_pushBack(&myList, 1); 209 | dlist_pushBack(&myList, 2); 210 | dlist_pushBack(&myList, 3); 211 | dlist_pushBack(&myList, 4); 212 | 213 | dlist_pushFront(&myList, 10); 214 | dlist_pushFront(&myList, 9); 215 | dlist_pushFront(&myList, 8); 216 | dlist_pushFront(&myList, 7); 217 | 218 | dlist_popBack(&myList); 219 | dlist_popFront(&myList); 220 | 221 | // Isi List => [8, 9, 10, 1, 2, 3] 222 | dlist_insertAt(&myList, 6, 100); 223 | dlist_insertAt(&myList, 1, 13); 224 | 225 | // Isi List => [8, 13, 9, 10, 1, 2, 3, 100] 226 | // printlist 227 | while (!dlist_isEmpty(&myList)) { 228 | printf("%d ", dlist_front(&myList)); 229 | dlist_popFront(&myList); 230 | } 231 | puts(""); 232 | return 0; 233 | } 234 | -------------------------------------------------------------------------------- /For C/D.Array, Stack, Queue, Deque, Pr.Queue/list_singly.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT SInglyList (Singly Linked List) 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C 8 | * 9 | * !!NOTE!! 10 | * cara menggunakan lihat pada fungsi main() 11 | */ 12 | 13 | #include 14 | #include 15 | #include 16 | 17 | /* Struktur Node */ 18 | 19 | typedef struct snode_t { 20 | int data; 21 | struct snode_t *next; 22 | } SListNode; 23 | 24 | /* Struktur ADT SinglyList */ 25 | 26 | typedef struct slist_t { 27 | unsigned _size; 28 | SListNode *_head; 29 | } SinglyList; 30 | 31 | /* DAFTAR FUNGSI YANG TERSEDIA */ 32 | 33 | void slist_init(SinglyList *list); 34 | bool slist_isEmpty(SinglyList *list); 35 | void slist_pushFront(SinglyList *list, int value); 36 | void slist_popFront(SinglyList *list); 37 | void slist_pushBack(SinglyList *list, int value); 38 | void slist_popBack(SinglyList *list); 39 | void slist_insertAt(SinglyList *list, int index, int value); 40 | void slist_removeAt(SinglyList *list, int index); 41 | void slist_remove(SinglyList *list, int value); 42 | int slist_front(SinglyList *list); 43 | int slist_back(SinglyList *list); 44 | int slist_getAt(SinglyList *list, int index); 45 | 46 | /* Function definition below */ 47 | 48 | void slist_init(SinglyList *list) 49 | { 50 | list->_head = NULL; 51 | list->_size = 0; 52 | } 53 | 54 | bool slist_isEmpty(SinglyList *list) { 55 | return (list->_head == NULL); 56 | } 57 | 58 | void slist_pushFront(SinglyList *list, int value) 59 | { 60 | SListNode *newNode = (SListNode*) malloc(sizeof(SListNode)); 61 | if (newNode) { 62 | list->_size++; 63 | newNode->data = value; 64 | 65 | if (slist_isEmpty(list)) newNode->next = NULL; 66 | else newNode->next = list->_head; 67 | list->_head = newNode; 68 | } 69 | } 70 | 71 | void slist_popFront(SinglyList *list) 72 | { 73 | if (!slist_isEmpty(list)) { 74 | SListNode *temp = list->_head; 75 | list->_head = list->_head->next; 76 | free(temp); 77 | list->_size--; 78 | } 79 | } 80 | 81 | void slist_pushBack(SinglyList *list, int value) 82 | { 83 | SListNode *newNode = (SListNode*) malloc(sizeof(SListNode)); 84 | if (newNode) { 85 | list->_size++; 86 | newNode->data = value; 87 | newNode->next = NULL; 88 | 89 | if (slist_isEmpty(list)) 90 | list->_head = newNode; 91 | else { 92 | SListNode *temp = list->_head; 93 | while (temp->next != NULL) 94 | temp = temp->next; 95 | temp->next = newNode; 96 | } 97 | } 98 | } 99 | 100 | void slist_popBack(SinglyList *list) 101 | { 102 | if (!slist_isEmpty(list)) { 103 | SListNode *nextNode = list->_head->next; 104 | SListNode *currNode = list->_head; 105 | 106 | if (currNode->next == NULL) { 107 | free(currNode); 108 | list->_head = NULL; 109 | return; 110 | } 111 | 112 | while (nextNode->next != NULL) { 113 | currNode = nextNode; 114 | nextNode = nextNode->next; 115 | } 116 | currNode->next = NULL; 117 | free(nextNode); 118 | list->_size--; 119 | } 120 | } 121 | 122 | void slist_insertAt(SinglyList *list, int index, int value) 123 | { 124 | /* Kasus apabila posisinya melebihi batas */ 125 | if (slist_isEmpty(list) || index >= list->_size) { 126 | slist_pushBack(list, value); 127 | return; 128 | } 129 | else if (index == 0 || index < 0) { 130 | slist_pushFront(list, value); 131 | return; 132 | } 133 | 134 | SListNode *newNode = (SListNode*) malloc(sizeof(SListNode)); 135 | if (newNode) { 136 | SListNode *temp = list->_head; 137 | int _i = 0; 138 | while (temp->next != NULL && _i < index-1) { 139 | temp = temp->next; 140 | _i++; 141 | } 142 | newNode->data = value; 143 | newNode->next = temp->next; 144 | temp->next = newNode; 145 | list->_size++; 146 | } 147 | } 148 | 149 | void slist_removeAt(SinglyList *list, int index) 150 | { 151 | if (!slist_isEmpty(list)) { 152 | 153 | /* Kasus apabila posisinya melebihi batas */ 154 | if (index >= list->_size) { 155 | slist_popBack(list); 156 | return; 157 | } 158 | else if (index == 0 || index < 0) { 159 | slist_popFront(list); 160 | return; 161 | } 162 | 163 | SListNode *temp = list->_head; 164 | int _i = 0; 165 | while (temp->next != NULL && _i < index-1) { 166 | temp = temp->next; 167 | _i++; 168 | } 169 | SListNode *nextTo = temp->next->next; 170 | free(temp->next); 171 | temp->next = nextTo; 172 | list->_size--; 173 | } 174 | } 175 | 176 | void slist_remove(SinglyList *list, int value) 177 | { 178 | if (!slist_isEmpty(list)) { 179 | SListNode *temp, *prev; 180 | temp = list->_head; 181 | 182 | if (temp->data == value) { 183 | slist_popFront(list); 184 | return; 185 | } 186 | while (temp != NULL && temp->data != value) { 187 | prev = temp; 188 | temp = temp->next; 189 | } 190 | 191 | if (temp == NULL) return; 192 | prev->next = temp->next; 193 | free(temp); 194 | list->_size--; 195 | } 196 | } 197 | 198 | int slist_front(SinglyList *list) 199 | { 200 | if (!slist_isEmpty(list)) { 201 | return list->_head->data; 202 | } 203 | return 0; 204 | } 205 | 206 | int slist_back(SinglyList *list) 207 | { 208 | if (!slist_isEmpty(list)) { 209 | SListNode *temp = list->_head; 210 | while (temp->next != NULL) 211 | temp = temp->next; 212 | return temp->data; 213 | } 214 | return 0; 215 | } 216 | 217 | int slist_getAt(SinglyList *list, int index) 218 | { 219 | if (!slist_isEmpty(list)) { 220 | SListNode *temp = list->_head; 221 | int _i = 0; 222 | while (temp->next != NULL && _i < index) { 223 | temp = temp->next; 224 | _i++; 225 | } 226 | return temp->data; 227 | } 228 | return 0; 229 | } 230 | 231 | int main(int argc, char const *argv[]) 232 | { 233 | // Buat objek SinglyList 234 | SinglyList myList; 235 | 236 | // PENTING! Jangan lupa diinisialisasi 237 | slist_init(&myList); 238 | 239 | // Gunakan operasi linked list 240 | slist_pushBack(&myList, 1); 241 | slist_pushBack(&myList, 2); 242 | slist_pushBack(&myList, 3); 243 | slist_pushBack(&myList, 4); 244 | 245 | slist_pushFront(&myList, 10); 246 | slist_pushFront(&myList, 9); 247 | slist_pushFront(&myList, 8); 248 | slist_pushFront(&myList, 7); 249 | 250 | slist_popBack(&myList); 251 | slist_popFront(&myList); 252 | 253 | // Isi List => [8, 9, 10, 1, 2, 3] 254 | 255 | slist_removeAt(&myList, 3); 256 | 257 | slist_insertAt(&myList, 1, 13); 258 | slist_pushBack(&myList, 1); 259 | slist_remove(&myList, 1); 260 | 261 | // Isi List => [8, 13, 9, 10, 2, 3] 262 | // printlist reversed 263 | while (myList._head != NULL) { 264 | printf("%d ", slist_back(&myList)); 265 | slist_popBack(&myList); 266 | } 267 | puts(""); 268 | return 0; 269 | } 270 | -------------------------------------------------------------------------------- /For C/D.Array, Stack, Queue, Deque, Pr.Queue/priority_queue_list.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT PriorityQueue menggunakan Linked List 3 | * [default: minimum priority] 4 | * 5 | * Dibuat dan ditulis oleh Bayu Laksana 6 | * -- tanggal 22 Januari 2019 7 | * Struktur Data 2020 8 | * Implementasi untuk bahasa C 9 | * 10 | * !!NOTE!! 11 | * cara menggunakan lihat pada fungsi main() 12 | */ 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | /* Struktur Node */ 19 | 20 | typedef struct pqueueNode_t { 21 | int data; 22 | struct pqueueNode_t *next; 23 | } PQueueNode; 24 | 25 | /* Struktur ADT PriorityQueue menggunakan Linked List */ 26 | 27 | // Prioritas default: nilai minimum 28 | typedef struct pqueue_t { 29 | PQueueNode *_top; 30 | unsigned _size; 31 | } PriorityQueue; 32 | 33 | /* Function prototype */ 34 | 35 | void pqueue_init(PriorityQueue *pqueue); 36 | bool pqueue_isEmpty(PriorityQueue *pqueue); 37 | void pqueue_push(PriorityQueue *pqueue, int value); 38 | void pqueue_pop(PriorityQueue *pqueue); 39 | int pqueue_top(PriorityQueue *pqueue); 40 | 41 | /* Function definition below */ 42 | 43 | void pqueue_init(PriorityQueue *pqueue) 44 | { 45 | pqueue->_top = NULL; 46 | pqueue->_size = 0; 47 | } 48 | 49 | bool pqueue_isEmpty(PriorityQueue *pqueue) { 50 | return (pqueue->_top == NULL); 51 | } 52 | 53 | void pqueue_push(PriorityQueue *pqueue, int value) 54 | { 55 | PQueueNode *temp = pqueue->_top; 56 | PQueueNode *newNode = \ 57 | (PQueueNode*) malloc (sizeof(PQueueNode)); 58 | newNode->data = value; 59 | newNode->next = NULL; 60 | 61 | if (pqueue_isEmpty(pqueue)) { 62 | pqueue->_top = newNode; 63 | return; 64 | } 65 | 66 | if (value < pqueue->_top->data) { 67 | newNode->next = pqueue->_top; 68 | pqueue->_top = newNode; 69 | } 70 | else { 71 | while ( temp->next != NULL && 72 | temp->next->data < value) 73 | temp = temp->next; 74 | newNode->next = temp->next; 75 | temp->next = newNode; 76 | } 77 | } 78 | 79 | void pqueue_pop(PriorityQueue *pqueue) 80 | { 81 | if (!pqueue_isEmpty(pqueue)) { 82 | PQueueNode *temp = pqueue->_top; 83 | pqueue->_top = pqueue->_top->next; 84 | free(temp); 85 | } 86 | } 87 | 88 | int pqueue_top(PriorityQueue *pqueue) { 89 | if (!pqueue_isEmpty(pqueue)) 90 | return pqueue->_top->data; 91 | else return 0; 92 | } 93 | 94 | int main(int argc, char const *argv[]) 95 | { 96 | // Buat objek PriorityQueue 97 | PriorityQueue myPque; 98 | 99 | // PENTING! Jangan lupa diinisialisasi 100 | pqueue_init(&myPque); 101 | 102 | // Operasi pada priority queue 103 | pqueue_push(&myPque, 12); 104 | pqueue_push(&myPque, 3); 105 | pqueue_push(&myPque, 1); 106 | 107 | // cetak isi pque 108 | while (!pqueue_isEmpty(&myPque)) { 109 | printf("%d ", pqueue_top(&myPque)); 110 | pqueue_pop(&myPque); 111 | } 112 | puts(""); 113 | return 0; 114 | } 115 | -------------------------------------------------------------------------------- /For C/D.Array, Stack, Queue, Deque, Pr.Queue/queue_array.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT QueueArray (Queue menggunakan array) 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C 8 | * 9 | * !!NOTE!! 10 | * cara menggunakan lihat pada fungsi main() 11 | */ 12 | 13 | #include 14 | #include 15 | #include 16 | 17 | /* Struktur ADT QueueArray */ 18 | 19 | typedef struct queuearr_t { 20 | int *_element; 21 | int _front, 22 | _rear; 23 | unsigned _size, _capacity; 24 | } QueueArray; 25 | 26 | /* Function prototype */ 27 | 28 | void queueArray_init(QueueArray *queue, unsigned queueSize); 29 | bool queueArray_isEmpty(QueueArray *queue); 30 | void queueArray_push(QueueArray *queue, int value); 31 | void queueArray_pop(QueueArray *queue); 32 | int queueArray_front(QueueArray *queue); 33 | unsigned queueArray_size(QueueArray *queue); 34 | 35 | /* Function definition below */ 36 | 37 | void queueArray_init(QueueArray *queue, unsigned queueSize) 38 | { 39 | queue->_element = (int*) malloc(sizeof(int) * queueSize); 40 | queue->_front = -1; 41 | queue->_rear = -1; 42 | queue->_size = 0; 43 | queue->_capacity = queueSize; 44 | } 45 | 46 | bool queueArray_isEmpty(QueueArray *queue) { 47 | return (queue->_front == -1); 48 | } 49 | 50 | void queueArray_push(QueueArray *queue, int value) 51 | { 52 | if (queue->_size + 1 <= queue->_capacity) { 53 | if (queue->_front == -1) 54 | queue->_front = 0; 55 | queue->_rear = (queue->_rear + 1) % queue->_capacity; 56 | queue->_element[queue->_rear] = value; 57 | queue->_size++; 58 | } 59 | } 60 | 61 | void queueArray_pop(QueueArray *queue) 62 | { 63 | if (!queueArray_isEmpty(queue)) { 64 | if (queue->_front == queue->_rear) 65 | queue->_front = queue->_rear = -1; 66 | else 67 | queue->_front = (queue->_front + 1) % queue->_capacity; 68 | queue->_size--; 69 | } 70 | } 71 | 72 | int queueArray_front(QueueArray *queue) 73 | { 74 | if (!queueArray_isEmpty(queue)) { 75 | return queue->_element[queue->_front]; 76 | } 77 | return 0; 78 | } 79 | 80 | unsigned queueArray_size(QueueArray *queue) { 81 | return (queue->_size); 82 | } 83 | 84 | int main(int argc, char const *argv[]) 85 | { 86 | // Buat objek QueueArray 87 | QueueArray myQueue; 88 | 89 | // PENTING! Jangan lupa diinisialisasi 90 | queueArray_init(&myQueue, 10); 91 | 92 | // Operasi pada queue 93 | queueArray_push(&myQueue, 1); 94 | queueArray_push(&myQueue, 2); 95 | queueArray_push(&myQueue, 3); 96 | 97 | // cetak isi queue 98 | while (!queueArray_isEmpty(&myQueue)) { 99 | printf("%d ", queueArray_front(&myQueue)); 100 | queueArray_pop(&myQueue); 101 | } 102 | puts(""); 103 | return 0; 104 | } 105 | -------------------------------------------------------------------------------- /For C/D.Array, Stack, Queue, Deque, Pr.Queue/queue_list.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT Queue (Queue menggunakan Linked List) 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C 8 | * 9 | * !!NOTE!! 10 | * cara menggunakan lihat pada fungsi main() 11 | */ 12 | 13 | #include 14 | #include 15 | #include 16 | 17 | /* Struktur Node */ 18 | 19 | typedef struct queueNode_t { 20 | int data; 21 | struct queueNode_t *next; 22 | } QueueNode; 23 | 24 | /* Struktur ADT Queue */ 25 | 26 | typedef struct queue_t { 27 | QueueNode *_front, 28 | *_rear; 29 | unsigned _size; 30 | } Queue; 31 | 32 | /* Function prototype */ 33 | 34 | void queue_init(Queue *queue); 35 | bool queue_isEmpty(Queue *queue); 36 | void queue_push(Queue *queue, int value); 37 | void queue_pop(Queue *queue); 38 | int queue_front(Queue *queue); 39 | int queue_size(Queue *queue); 40 | 41 | /* Function definition below */ 42 | 43 | void queue_init(Queue *queue) 44 | { 45 | queue->_size = 0; 46 | queue->_front = NULL; 47 | queue->_rear = NULL; 48 | } 49 | 50 | bool queue_isEmpty(Queue *queue) { 51 | return (queue->_front == NULL && queue->_rear == NULL); 52 | } 53 | 54 | void queue_push(Queue *queue, int value) 55 | { 56 | QueueNode *newNode = (QueueNode*) malloc(sizeof(QueueNode)); 57 | if (newNode) { 58 | queue->_size++; 59 | newNode->data = value; 60 | newNode->next = NULL; 61 | 62 | if (queue_isEmpty(queue)) 63 | queue->_front = queue->_rear = newNode; 64 | else { 65 | queue->_rear->next = newNode; 66 | queue->_rear = newNode; 67 | } 68 | } 69 | } 70 | 71 | void queue_pop(Queue *queue) 72 | { 73 | if (!queue_isEmpty(queue)) { 74 | QueueNode *temp = queue->_front; 75 | queue->_front = queue->_front->next; 76 | free(temp); 77 | 78 | if (queue->_front == NULL) 79 | queue->_rear = NULL; 80 | queue->_size--; 81 | } 82 | } 83 | 84 | int queue_front(Queue *queue) 85 | { 86 | if (!queue_isEmpty(queue)) { 87 | return (queue->_front->data); 88 | } 89 | return (int)0; 90 | } 91 | 92 | int queue_size(Queue *queue) { 93 | return queue->_size; 94 | } 95 | 96 | int main(int argc, char const *argv[]) 97 | { 98 | // Buat objek QueueArray 99 | Queue myQueue; 100 | 101 | // PENTING! Jangan lupa diinisialisasi 102 | queue_init(&myQueue); 103 | 104 | // Operasi pada queue 105 | queue_push(&myQueue, 1); 106 | queue_push(&myQueue, 2); 107 | queue_push(&myQueue, 3); 108 | 109 | // cetak isi queue 110 | while (!queue_isEmpty(&myQueue)) { 111 | printf("%d ", queue_front(&myQueue)); 112 | queue_pop(&myQueue); 113 | } 114 | puts(""); 115 | return 0; 116 | } 117 | -------------------------------------------------------------------------------- /For C/D.Array, Stack, Queue, Deque, Pr.Queue/stack_array.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT StackArray (Stack menggunakan static Array) 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C 8 | * 9 | * !!NOTE!! 10 | * cara menggunakan lihat pada fungsi main() 11 | */ 12 | 13 | #include 14 | #include 15 | #include 16 | 17 | /* Struktur ADT StackArray */ 18 | 19 | typedef struct stackarr_t { 20 | int *_element, _topIndex; 21 | unsigned int _size, _capacity; 22 | } StackArray; 23 | 24 | /* Function prototype */ 25 | 26 | void stackArray_init(StackArray *stack, unsigned stackSize); 27 | bool stackArray_isEmpty(StackArray *stack); 28 | void stackArray_push(StackArray *stack, int value); 29 | void stackArray_pop(StackArray *stack); 30 | int stackArray_top(StackArray *stack); 31 | 32 | /* Function definition below */ 33 | 34 | void stackArray_init(StackArray *stack, unsigned int stackSize) 35 | { 36 | stack->_element = (int*) malloc(sizeof(int) * stackSize); 37 | stack->_size = 0; 38 | stack->_topIndex = -1; 39 | stack->_capacity = stackSize; 40 | } 41 | 42 | bool stackArray_isEmpty(StackArray *stack) { 43 | return (stack->_topIndex == -1); 44 | } 45 | 46 | void stackArray_push(StackArray *stack, int value) 47 | { 48 | if (stack->_size + 1 <= stack->_capacity) { 49 | stack->_element[++stack->_topIndex] = value; 50 | stack->_size++; 51 | } 52 | } 53 | 54 | void stackArray_pop(StackArray *stack) 55 | { 56 | if (!stackArray_isEmpty(stack)) { 57 | stack->_topIndex--; 58 | stack->_size--; 59 | } 60 | } 61 | 62 | int stackArray_top(StackArray *stack) 63 | { 64 | if (!stackArray_isEmpty(stack)) { 65 | return stack->_element[stack->_topIndex]; 66 | } 67 | return 0; 68 | } 69 | 70 | int main(int argc, char const *argv[]) 71 | { 72 | // Buat objek StackArray 73 | StackArray myStack; 74 | 75 | // PENTING! Jangan lupa diinisialisasi 76 | stackArray_init(&myStack, 10); 77 | 78 | // Operasi pada stack 79 | stackArray_push(&myStack, 1); 80 | stackArray_push(&myStack, 2); 81 | stackArray_push(&myStack, 3); 82 | 83 | // cetak isi stack 84 | while (!stackArray_isEmpty(&myStack)) { 85 | printf("%d ", stackArray_top(&myStack)); 86 | stackArray_pop(&myStack); 87 | } 88 | puts(""); 89 | return 0; 90 | } 91 | -------------------------------------------------------------------------------- /For C/D.Array, Stack, Queue, Deque, Pr.Queue/stack_list.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Implementasi ADT Stack (Stack menggunakan Linked List) 3 | * 4 | * Dibuat dan ditulis oleh Bayu Laksana 5 | * -- tanggal 22 Januari 2019 6 | * Struktur Data 2020 7 | * Implementasi untuk bahasa C 8 | * 9 | * !!NOTE!! 10 | * cara menggunakan lihat pada fungsi main() 11 | */ 12 | 13 | #include 14 | #include 15 | #include 16 | 17 | /* Struktur Node */ 18 | 19 | typedef struct stackNode_t { 20 | int data; 21 | struct stackNode_t *next; 22 | } StackNode; 23 | 24 | /* Struktur ADT Stack */ 25 | 26 | typedef struct stack_t { 27 | StackNode *_top; 28 | unsigned _size; 29 | } Stack; 30 | 31 | /* Function prototype */ 32 | 33 | void stack_init(Stack *stack); 34 | bool stack_isEmpty(Stack *stack); 35 | void stack_push(Stack *stack, int value); 36 | void stack_pop(Stack *stack); 37 | int stack_top(Stack *stack); 38 | unsigned stack_size(Stack *stack); 39 | 40 | /* Function definition below */ 41 | 42 | void stack_init(Stack *stack) 43 | { 44 | stack->_size = 0; 45 | stack->_top = NULL; 46 | } 47 | 48 | bool stack_isEmpty(Stack *stack) { 49 | return (stack->_top == NULL); 50 | } 51 | 52 | void stack_push(Stack *stack, int value) 53 | { 54 | StackNode *newNode = (StackNode*) malloc(sizeof(StackNode)); 55 | if (newNode) { 56 | stack->_size++; 57 | newNode->data = value; 58 | 59 | if (stack_isEmpty(stack)) newNode->next = NULL; 60 | else newNode->next = stack->_top; 61 | 62 | stack->_top = newNode; 63 | } 64 | } 65 | 66 | void stack_pop(Stack *stack) 67 | { 68 | if (!stack_isEmpty(stack)) { 69 | StackNode *temp = stack->_top; 70 | stack->_top = stack->_top->next; 71 | free(temp); 72 | stack->_size--; 73 | } 74 | } 75 | 76 | int stack_top(Stack *stack) 77 | { 78 | if (!stack_isEmpty(stack)) 79 | return stack->_top->data; 80 | return 0; 81 | } 82 | 83 | unsigned stack_size(Stack *stack) { 84 | return stack->_size; 85 | } 86 | 87 | int main(int argc, char const *argv[]) 88 | { 89 | // Buat objek Stack 90 | Stack myStack; 91 | 92 | // PENTING! Jangan lupa diinisialisasi 93 | stack_init(&myStack); 94 | 95 | // Operasi pada stack 96 | stack_push(&myStack, 1); 97 | stack_push(&myStack, 2); 98 | stack_push(&myStack, 3); 99 | 100 | // cetak isi stack 101 | while (!stack_isEmpty(&myStack)) { 102 | printf("%d ", stack_top(&myStack)); 103 | stack_pop(&myStack); 104 | } 105 | puts(""); 106 | return 0; 107 | } -------------------------------------------------------------------------------- /Made by bayulaxana/AVL Tree (Map and Set)/Map.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * [MADE WITH ❤ by BAYU LAKSANA] 3 | * 4 | * Here is a comprehensive and elegant implementation of 5 | * Map Abstract Data Type (ADT) using AVL Tree Data Structures 6 | * 7 | * Read the Documentation on README 8 | * https://github.com/AlproITS/StrukturData/blob/master/Made%20by%20bayulaxana/AVL%20Tree%20(Map%20and%20Set)/README.md 9 | */ 10 | 11 | #include 12 | #include 13 | #include 14 | 15 | /** 16 | * "NodeData" is used to store 17 | * the key-value pair, the basic behaviour 18 | * of Map ADT. 19 | * 20 | * [ Default data type ] 21 | * - key : int 22 | * - value : int 23 | */ 24 | struct NodeData { 25 | int key, value; 26 | }; 27 | 28 | /** 29 | * "Node" represents a node in AVL-Tree 30 | */ 31 | struct Node { 32 | NodeData data; 33 | Node *left, *right; 34 | int height, balanceFactor; 35 | 36 | Node() {} 37 | Node(NodeData &keyValue) 38 | { 39 | left = nullptr; 40 | right = nullptr; 41 | data.key = keyValue.key; 42 | data.value = keyValue.value; 43 | } 44 | }; 45 | 46 | /** 47 | * Map ADT implementation using AVL-Tree 48 | * [ Default data type ] 49 | * - key : int 50 | * - value : int 51 | */ 52 | class Map 53 | { 54 | Node *_root; 55 | unsigned _size; 56 | 57 | void _update(Node *node) { 58 | int leftNodeHeight = (node->left == nullptr) ? -1 : node->left->height; 59 | int rightNodeHeight = (node->right == nullptr) ? -1 : node->right->height; 60 | 61 | node->height = 1 + std::max(leftNodeHeight, rightNodeHeight); 62 | node->balanceFactor = rightNodeHeight - leftNodeHeight; 63 | } 64 | 65 | Node* _rightRotation(Node *node) { 66 | Node *newParent = node->left; 67 | node->left = newParent->right; 68 | newParent->right = node; 69 | _update(node); 70 | _update(newParent); 71 | return newParent; 72 | } 73 | 74 | Node* _leftRotation(Node *node) { 75 | Node *newParent = node->right; 76 | node->right = newParent->left; 77 | newParent->left = node; 78 | _update(node); 79 | _update(newParent); 80 | return newParent; 81 | } 82 | 83 | Node* _leftLeft(Node *node) { 84 | return _rightRotation(node); 85 | } 86 | 87 | Node* _rightRight(Node *node) { 88 | return _leftRotation(node); 89 | } 90 | 91 | Node* _leftRight(Node *node) { 92 | node->left = _leftRotation(node->left); 93 | return _leftLeft(node); 94 | } 95 | 96 | Node* _rightLeft(Node *node) { 97 | node->right = _rightRotation(node->right); 98 | return _rightRight(node); 99 | } 100 | 101 | Node* _balance(Node *node) { 102 | if (node->balanceFactor == -2) { 103 | if (node->left->balanceFactor <= 0) 104 | return _leftLeft(node); 105 | else 106 | return _leftRight(node); 107 | } 108 | else if (node->balanceFactor == 2) { 109 | if (node->right->balanceFactor >= 0) 110 | return _rightRight(node); 111 | else 112 | return _rightLeft(node); 113 | } 114 | return node; 115 | } 116 | 117 | Node* _search(Node *node, int key) { 118 | while (node != nullptr) { 119 | if (key < node->data.key) 120 | node = node->left; 121 | else if (key > node->data.key) 122 | node = node->right; 123 | else 124 | return node; 125 | } 126 | return node; 127 | } 128 | 129 | Node* _insert(Node *node, NodeData &keyValuePair) { 130 | if (node == nullptr) return new Node(keyValuePair); 131 | 132 | if (keyValuePair.key < node->data.key) 133 | node->left = _insert(node->left, keyValuePair); 134 | else if (keyValuePair.key > node->data.key) 135 | node->right = _insert(node->right, keyValuePair); 136 | else 137 | node->data = keyValuePair; 138 | 139 | _update(node); 140 | return _balance(node); 141 | } 142 | 143 | Node* _deleteAll(Node *node) { 144 | if (node == nullptr) return nullptr; 145 | 146 | node->left = _deleteAll(node->left); 147 | node->right = _deleteAll(node->right); 148 | 149 | delete node; 150 | return nullptr; 151 | } 152 | 153 | public: 154 | Map(): _size(0U), _root(nullptr) 155 | {} 156 | 157 | ~Map() { 158 | clear(); 159 | delete _root; 160 | } 161 | 162 | bool isEmpty() { 163 | return _root == nullptr; 164 | } 165 | 166 | unsigned size() { 167 | return _size; 168 | } 169 | 170 | void clear() { 171 | _root = _deleteAll(_root); 172 | _size = 0U; 173 | } 174 | 175 | bool exist(int key) { 176 | Node *temp = _search(_root, key); 177 | if (!temp) return false; 178 | return (temp->data.key == key); 179 | } 180 | 181 | void insert(NodeData keyValuePair) { 182 | if (!exist(keyValuePair.key)) { 183 | _root = _insert(_root, keyValuePair); 184 | _size++; 185 | } 186 | } 187 | 188 | void assign(NodeData keyValuePair) { 189 | if (!exist(keyValuePair.key)) { 190 | _root = _insert(_root, keyValuePair); 191 | _size++; 192 | } 193 | else { 194 | _root = _insert(_root, keyValuePair); 195 | } 196 | } 197 | 198 | void remove(int key) { 199 | if (exist(key)) { 200 | // _root = 201 | _size--; 202 | } 203 | } 204 | 205 | int getValue(int key) { 206 | if (exist(key)) 207 | return _search(_root, key)->data.value; 208 | else exit(-1); 209 | } 210 | }; 211 | 212 | int main(int argc, char const *argv[]) 213 | { 214 | Map mp; 215 | 216 | // Map::assign( {key, value} ); 217 | // insert key-value pairs if doesn't exist yet, or 218 | // change the value of already-inserted key 219 | mp.assign({11, 23}); 220 | mp.assign({1, 16}); 221 | mp.assign({9, 12}); 222 | mp.assign({9, 100}); 223 | 224 | // Map::getValue(key) 225 | // get the value of already-inserted key-value pairs 226 | int foo = mp.getValue(1); 227 | std::cout << foo << '\n'; 228 | return 0; 229 | } 230 | -------------------------------------------------------------------------------- /Made by bayulaxana/AVL Tree (Map and Set)/README.md: -------------------------------------------------------------------------------- 1 | ### [IN PROGRESS] 2 | 3 | - ADT Set 4 | - Removal in Map 5 | - Documentation -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## Petunjuk 2 | 3 | ### Folder "For C" 4 | 5 | Berisi source code yang diimplementasikan untuk bahasa C. 6 | 7 | ### Folder "For C++" 8 | 9 | Berisi source code yang diimplementasikan untuk bahasa C++. --------------------------------------------------------------------------------