Jenis-jenis Struktur Data dalam Algoritma C++

using namespace std;

class DynamicArray
{
private:
    int size_;
    int max_;
    int *arrayholder_;

public:
    DynamicArray()
    {
        this->size_ = 0;
        this->max_ = 5;
        this->arrayholder_ = new int[5];
    }

    ~DynamicArray()
    {
        delete[] this->arrayholder_;
    }

    int size()
    {
        return this->size_;
    }

    int& operator[](int i) 
    {
        assert(i < this->size_);
        return this->arrayholder_[i];
    }

    void add(int n)
    {
        if (this->max_ < this->size_ + 1)
        {
            this->max_ *= 2;
            int *tmp_ = new int[this->max_];

            for (size_t i = 0; i < this->size_; i++)
            {
                tmp_[i] = this->arrayholder_[i];
                
            }
            delete[] this->arrayholder_;
            this->arrayholder_ = tmp_;
            this->arrayholder_[this->size_] = n;
            this->size_ += 1;
        }
        else 
        {
            this->arrayholder_[this->size_] = n;
            this->size_ += 1;
        }
    }
};

int main(int argc, char **argv)
{
    DynamicArray darray;
  
    vector<int> varray;

    for (size_t i = 0; i <= 15; i++)
    {
        darray.add(i);
    }
    return 0;
}

#include <iostream>
#include <vector> 
using namespace std;

template <typename T>
class Node {
    public:
    T value;
    Node *next;
    Node *previous;

    Node(T value) {
        this->value = value;
    }
};

template <typename T>
class LinkedList {
    private:
    int size_;
    Node<T> *head_ = NULL;
    Node<T> *tail_ = NULL;
    Node<T> *itr_ = NULL;

    public:
    LinkedList() {
        this->size_ = 0;
    }

    void append(T value) {
        if (this->head_ == NULL) {
            this->head_ = new Node<T>(value);
            this->tail_ = this->head_;
        }
        else {
            this->tail_->next = new Node<T>(value);
            this->tail_->next->previous = this->tail_;
            this->tail_ = this->tail_->next;
        }
        this->size_ += 1;
    }

    void prepend(T value) {
        if (this->head_ == NULL) {
            this->head_ = new Node<T>(value);
            this->tail_ = this->head_;
        }
        else {
            this->head_->previous = new Node<T>(value);
            this->head_->previous->next = this->head_;
            this->head_ = this->head_->previous;
        }
        this->size_ += 1;
    }

    Node<T> * iterate() {
        if (this->itr_ == NULL)  {
            this->itr_ = this->head_;
        } 
        else  {
            this->itr_ = this->itr_->next;
        }
        return this->itr_;
    }

    T ptr() {
        return this->itr_->value;
    }

    void resetIterator() {
        this->tail_ = NULL;
    }
};


int main(int argc, char **argv) {
    LinkedList<int> llist;
    llist.append(10);
    llist.append(12);
    llist.append(14);
    llist.append(16);
    llist.prepend(5);
    llist.prepend(4);
    llist.prepend(3);
    llist.prepend(2);
    llist.prepend(1);

    cout << "Printing Linked List" << endl;

    while(llist.iterate() != NULL) {
        cout << llist.ptr() << "\t";
    }
    cout << endl;

    return 0;
}

#include <iostream>
using namespace std;

template <typename T>
class Node {
public:
    T value;
    Node *next;

    Node(T value) {
        this->value = value;
    }
};

template <typename T>
class Stack {
private:
    int size_;
    Node<T> *top_ = NULL;
    Node<T> *itr_ = NULL;

public:
    Stack() {
        this->size_ = 0;
    }

    void push(T value) {
        if (this->top_ == NULL) {
            this->top_ = new Node<T>(value);
        }
        else {
            Node<T> *tmp = new Node<T>(value);
            tmp->next = this->top_;
            this->top_ = tmp;
        }
        this->size_ += 1;
    }

    Node<T> *pop() {
        Node<T> *tmp = this->top_;

        this->top_ = this->top_->next;
        this->size_ -= 1;
        return tmp;
    }

    Node<T> *peek() {
        return this->top_;
    }

    int size() {
        return this->size_;
    }

    Node<T> *iterate() {
        if (this->itr_ == NULL) {
            this->itr_ = this->top_;
        }
        else {
            this->itr_ = this->itr_->next;
        }
        return this->itr_;
    }


  
    T ptr() {
        return this->itr_->value;
    }

    void resetIterator() {
        this->itr_ = NULL;
    }
};

int main(int argc, char **argv) {
    Stack<int> stk1;
    stk1.push(10);
    stk1.push(12);
    stk1.push(14);
    stk1.push(16);
    stk1.push(5);
    stk1.push(4);
    stk1.push(3);
    stk1.push(2);
    stk1.push(1);

    cout << "Printing Stack" << endl;

    while (stk1.iterate() != NULL) {
        cout << stk1.ptr() << "\t";
    }
    
    cout << endl;
    return 0;
}

#include <iostream>
using namespace std;

template <typename T>
class Queue {
    private:
    int size_;
    Node<T> *head_ = NULL;
    Node<T> *tail_ = NULL;

    public:
    Queue() {
        this->size_ = 0;
    }

    void enqueue(T value) {
        if (this->head_ == NULL) {
            this->head_ = new Node<T>(value);
            this->tail_ = this->head_;
        }
        else {
            this->tail_->next = new Node<T>(value);
            this->tail_->next->previous = this->tail_;
            this->tail_ = this->tail_->next;
        }
        this->size_ += 1;
    }

    Node<T> dequeue() {
        Node<T> *tmp = this->tail_;

        this->tail_ = this->tail->previous;
        this->tail_->next = NULL;
        this->size_ -= 1;
        return tmp;
    }
};

#include<bits/stdc++.h>
using namespace std;

class Hash {
    int BUCKET;    // No. of buckets
 
    // Pointer to an array containing buckets
    list<int> *table;
public:
    Hash(int V);  // Constructor
 
    // inserts a key into hash table
    void insertItem(int x);
 
    // deletes a key from hash table
    void deleteItem(int key);
 
    // hash function to map values to key
    int hashFunction(int x) {
        return (x % BUCKET);
    }
 
  
    void displayHash();
};
 
Hash::Hash(int b) {
    this->BUCKET = b;
    table = new list<int>[BUCKET];
}
 
void Hash::insertItem(int key) {
    int index = hashFunction(key);
    table[index].push_back(key);
}
 
void Hash::deleteItem(int key) {
  // get the hash index of key
  int index = hashFunction(key);
 
  // find the key in (index)th list
  list <int> :: iterator i;
  for (i = table[index].begin();
           i != table[index].end(); i++) {
    if (*i == key)
      break;
  }
 
  // if key is found in hash table, remove it
  if (i != table[index].end())
    table[index].erase(i);
}
 
// function to display hash table
void Hash::displayHash() {
  for (int i = 0; i < BUCKET; i++) {
    cout << i;
    for (auto x : table[i])
      cout << " --> " << x;
    cout << endl;
  }
}
 
// Driver program
int main() {
  // array that contains keys to be mapped
  int a[] = {15, 11, 27, 8, 12};
  int n = sizeof(a)/sizeof(a[0]);
 
  // insert the keys into the hash table
  Hash h(7);   // 7 is count of buckets in
               // hash table
  for (int i = 0; i < n; i++)
    h.insertItem(a[i]); 
 
  // delete 12 from hash table
  h.deleteItem(12);
 
  // display the Hash table
  h.displayHash();
 
  return 0;
}