fork download
copy 
  1. #include <iostream>
  2. using namespace std;
  3.  
  4. class IntDLinkedList
  5. {
  6. private:
  7.     class Node;
  8. private:
  9.     Node *head;
  10.     Node *tail;
  11.     int count;
  12. public:
  13.     IntDLinkedList() : head(NULL), tail(NULL), count(0) {}
  14.     ~IntDLinkedList()
  15.     {
  16.         this->clear();
  17.     }
  18.     void add(int element)
  19. {
  20.     Node *pNew = new Node(element);
  21.     if(head==NULL){
  22.         head = pNew;
  23.         tail = pNew;
  24.         count++;
  25.     }
  26.     else{
  27.         tail->next = pNew;
  28.         pNew->prev = tail;
  29.         tail = pNew;
  30.         count++;
  31.     }
  32. }
  33.  
  34. void add(int index, int element)
  35. {
  36.     if(index<0||index>count){
  37.         throw std::out_of_range("");
  38.     }
  39.     Node *pNew = new Node(element);
  40.     if(head == NULL){
  41.         head = pNew;
  42.         tail = pNew;
  43.         count++;
  44.     }
  45.     if(index == 0){
  46.         pNew->next = head;
  47.         head->prev = pNew;
  48.         head = pNew;
  49.         count++;
  50.     }
  51.     else if(index == count){
  52.         pNew->prev = tail;
  53.         tail->next = pNew;
  54.         tail = pNew;
  55.         count++;
  56.     }
  57.     else{
  58.         Node *pre = head;
  59.         for(int i =0; i<index - 1; i++){
  60.             pre = pre->next;
  61.         }
  62.         Node *temp = pre->next;
  63.         pNew->next = temp;
  64.         pNew->prev = pre;
  65.         pre->next = pNew;
  66.         temp->prev = pNew;
  67.         count++;
  68.     }
  69. }
  70.  
  71. int removeAt(int index)
  72. {
  73.     int val;
  74.     if(index>=count||index<0){
  75.         throw std::out_of_range("");
  76.     }
  77.     else if(index == 0){
  78.         Node *temp = head;
  79.         val = temp->value;
  80.         head = head->next;
  81.         head->prev = NULL;
  82.         delete temp;
  83.         count--;
  84.     }
  85.     else if(index == count){
  86.         Node *temp = tail;
  87.         val = temp->value;
  88.         tail = tail->prev;
  89.         tail->next=NULL;
  90.         delete temp;
  91.         count--;
  92.     }
  93.     else{
  94.         Node *pre = head;
  95.         for(int i =0; i<index-1; i++){
  96.             pre = pre->next;
  97.         }
  98.         Node *temp = pre->next;
  99.         temp->next->prev=pre;
  100.         pre->next = temp->next;
  101.         val = temp->value;
  102.         delete temp;
  103.         count--;
  104.     }
  105.     return val;
  106. }
  107.  
  108. bool removeItem(int element)
  109. {
  110.     Node *pre = head;
  111.     while(pre!=NULL){
  112.         if(pre->value==element){
  113.             Node *temp = pre;
  114.             pre->prev->next = pre->next;
  115.             pre->next->prev = pre->prev;
  116.             delete temp;
  117.             count--;
  118.             return true;
  119.         }
  120.     }
  121.     return false;
  122. }
  123.  
  124. int get(int index)
  125. {
  126.     int val;
  127.     if(index<0||index>=count-1){
  128.         throw std::out_of_range("");
  129.     }
  130.     else if(index == 0){
  131.         val = head->value;
  132.     }
  133.     else if(index == count - 1){
  134.         val = tail->value;
  135.     }
  136.     else{
  137.         Node *pre = head;
  138.         for(int i=0; i<index; i++){
  139.             pre = pre->next;
  140.         }
  141.         val = pre->value;
  142.     }
  143.     return val;
  144. }
  145.  
  146. void set(int index, int element)
  147. {
  148.     if(index<0||index>=count-1){
  149.         throw std::out_of_range("");
  150.     }
  151.     else if(index == 0){
  152.         head->value = element;
  153.     }
  154.     else if(index == count -1){
  155.         tail->value = element;
  156.     }
  157.     else{
  158.         Node* pre = head;
  159.         for(int i =0; i<index; i++){
  160.             pre = pre->next;
  161.         }
  162.         pre->value = element;
  163.     }
  164. }
  165.  
  166. int indexOf(int element)
  167. {
  168.     Node *pre = head;
  169.     int idx = 0;
  170.     while(pre!=NULL){
  171.         if(pre->value==element){
  172.             return idx;
  173.         }
  174.         else{
  175.             pre = pre->next;
  176.             idx++;
  177.         }
  178.     }
  179.     return -1;
  180. }
  181.  
  182. bool contains(int element)
  183. {
  184.     Node* pre = head;
  185.     while(pre!=NULL){
  186.         if(pre->value==element){
  187.             return true;
  188.         }
  189.         else{
  190.             pre = pre->next;
  191.         }
  192.     }
  193.     return false;
  194. }
  195.  
  196. int size()
  197. {
  198.     return count;
  199. }
  200.  
  201. bool empty()
  202. {
  203.     if(head==NULL)
  204.     return true;
  205.     return false;
  206. }
  207.  
  208.  
  209. void clear()
  210. {
  211.  
  212. }
  213.     void dump()
  214.     {
  215.         cout << "List: [";
  216.         Node *temp = this->head;
  217.         while (temp != this->tail)
  218.         {
  219.             cout << temp->value << ",";
  220.             temp = temp->next;
  221.         }
  222.         cout << temp->value << "]" << endl;
  223.         cout << "Reverse list: [";
  224.         temp = this->tail;
  225.         while (temp != this->head)
  226.         {
  227.             cout << temp->value << ",";
  228.             temp = temp->prev;
  229.         }
  230.         cout << temp->value << "]" << endl;
  231.     }
  232.  
  233. private:
  234.     class Node
  235.     {
  236.     public:
  237.         int value;
  238.         Node *prev;
  239.         Node *next;
  240.         Node(int value = 0, Node *prev = NULL, Node *next = NULL) : value(value), prev(prev), next(next) {}
  241.     };
  242. };
  243.  
  244. int main(){
  245. 	IntDLinkedList list;
  246. 	cout << list.empty() << endl;
  247. 	int values[]   = {10, 15, 2,  6,  4,  7,  40,  8};
  248. 	int index[]    = {0,  0,  1,  3,  2,  3,  5,   0};
  249. 	for (int idx = 0; idx < 8; idx++){
  250. 		list.add(index[idx], values[idx]);
  251. 	}
  252.  
  253. 	cout << list.empty() << endl;
  254. 	list.dump();
  255. 	return 0;
  256. }
Success #stdin #stdout 0.01s 5512KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
1
0
List: [8,15,2,4,7,10]
Reverse list: [10,7,4,2,15,8]
https://ideone.com/3uJQ2S
language:
C++ (gcc 8.3)
created:
1 year ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!