SaveText.Ru

  1. #pragma once
  2. #include <iostream>
  3. #include <list>
  4. using namespace std;
  5.  
  6. template <typename T>
  7. class mylist
  8. {
  9. public:
  10.         class node
  11.         {
  12.         public:
  13.                 T data;
  14.                 node* prev;
  15.                 node* next;
  16.         };
  17.         int size;
  18.         node* Head;
  19.         node* Tail;
  20.         //Конструкторы
  21.         mylist()
  22.         {
  23.                 size = 0;
  24.                 Head = NULL;
  25.                 Tail = NULL;
  26.         }
  27.         mylist(int x)
  28.         {
  29.                 for (int i; i < x; i++)
  30.                 {
  31.                         node* temp = new node;
  32.                         if (i == 0)
  33.                         {
  34.                                 Head = temp;
  35.                                 Tail = temp;
  36.                                 temp->prev = NULL;
  37.                                 temp->data = 0;
  38.                         }
  39.                         else
  40.                                 this->push_back(0);
  41.                         temp->next = NULL;
  42.                 }
  43.         }
  44.         mylist(mylist& list)
  45.         {
  46.                 this->clear();
  47.                 node* temp = new node;
  48.                 temp = list.Head;
  49.                 while (temp)
  50.                 {
  51.                         this->push_back(temp->data);
  52.                         temp = temp->next;
  53.                 }
  54.                 delete temp;
  55.         }
  56.         //Деструктор
  57.         ~mylist()
  58.         {
  59.                 if (size == 0)
  60.                         return;
  61.                 node* temp = new node;
  62.                 temp = Head;
  63.                 while (temp != NULL)
  64.                 {
  65.                         node* delnode = new node;
  66.                         delnode = temp;
  67.                         temp = temp->next;
  68.                         delete delnode;
  69.                 }
  70.                 delete temp;
  71.                 Head = NULL;
  72.                 Tail = NULL;
  73.                 size = 0;
  74.         }
  75.         //Методы
  76.         void print()
  77.         {
  78.                 if (size == 0)
  79.                 {
  80.                         cout << "Список пуст" << endl;
  81.                         return;
  82.                 }
  83.                 else
  84.                 {
  85.                         node* temp = new node;
  86.                         temp = Head;
  87.                         while (temp)
  88.                         {
  89.                                 cout << temp->data << "t";
  90.                                 temp = temp->next;
  91.                         }
  92.                         cout << endl;
  93.                         delete temp;
  94.                 }
  95.         }
  96.         void assign(int count, T x)
  97.         {
  98.                 node* temp = new node;
  99.                 temp = Head;
  100.                 for (int i = 0; i < count; i++)
  101.                 {
  102.                         if (temp == NULL)
  103.                                 break;
  104.                         temp->data = x;
  105.                         temp = temp->next;
  106.                 }
  107.         }
  108.         node* back()
  109.         {
  110.                 return Tail;
  111.         };
  112.         void clear()
  113.         {
  114.                 Head = NULL;
  115.                 Tail = NULL;
  116.                 size = 0;
  117.         }
  118.         bool empty()
  119.         {
  120.  
  121.                 if (size == 0)
  122.                         return 1;
  123.                 else
  124.                         return 0;
  125.  
  126.         }
  127.         node* front()
  128.         {
  129.                 return Head;
  130.         };
  131.         void insert(int pos, T x)
  132.         {
  133.                 if ((pos > size) || (size == 0) || (pos < 0))
  134.                         return;
  135.                 node* temp = new node;
  136.                 temp = Head;
  137.                 for (int i = 0; i < pos; i++)
  138.                         temp = temp->next;
  139.                 node* newnode = new node;
  140.                 if (pos == size)
  141.                 {
  142.                         newnode->prev = Tail;
  143.                         Tail->next = newnode;
  144.                         newnode->next = NULL;
  145.                         Tail = newnode;
  146.                 }
  147.                 else if (pos == 0)
  148.                 {
  149.                         newnode->next = Head;
  150.                         Head->prev = newnode;
  151.                         newnode->prev = NULL;
  152.                         Head = newnode;
  153.                 }
  154.                 else
  155.                 {
  156.                         node* prevtemp = new node;
  157.                         prevtemp = temp->prev;
  158.                         prevtemp->next = newnode;
  159.                         temp->prev = newnode;
  160.                         newnode->next = temp;
  161.                         newnode->prev = prevtemp;
  162.                 }
  163.                 newnode->data = x;
  164.                 size++;
  165.         }
  166.         void pop_back()
  167.         {
  168.                 node* temp = new node;
  169.                 if (size == 1)
  170.                 {
  171.                         delete temp;
  172.                         Head = NULL;
  173.                         Tail = NULL;
  174.                         return;
  175.                 }
  176.                 temp = Tail;
  177.                 Tail = temp->prev;
  178.                 Tail->next = NULL;
  179.                 delete temp;
  180.                 size--;
  181.         }
  182.         void pop_front()
  183.         {
  184.                 node* temp = new node;
  185.                 temp = Head;
  186.                 Head = temp->next;
  187.                 Head->prev = NULL;
  188.                 delete temp;
  189.                 size--;
  190.         }
  191.         void push_back(T x)
  192.         {
  193.                 node* temp = new node;
  194.                 if (size == 0)
  195.                 {
  196.                         Head = temp;
  197.                         Tail = temp;
  198.                         temp->prev = NULL;
  199.                 }
  200.                 else
  201.                 {
  202.                         Tail->next = temp;
  203.                         temp->prev = Tail;
  204.                         Tail = temp;
  205.                 }
  206.                 temp->data = x;
  207.                 temp->next = NULL;
  208.                 size++;
  209.         }
  210.         void push_front(T x)
  211.         {
  212.                 node* temp = new node;
  213.                 if (size == 0)
  214.                 {
  215.                         Head = temp;
  216.                         Tail = temp;
  217.                         temp->prev = NULL;
  218.                         temp->next = NULL;
  219.                 }
  220.                 else
  221.                 {
  222.                         Head->prev = temp;
  223.                         temp->next = Head;
  224.                         Head = temp;
  225.                 }
  226.                 temp->data = x;
  227.                 temp->prev = NULL;
  228.                 size++;
  229.         }
  230.         void resize(int x)
  231.         {
  232.                 if (x < 0)
  233.                         return;
  234.                 if (x == 0)
  235.                         this->clear();
  236.                 else if (x <= size)
  237.                 {
  238.                         node* temp = new node;
  239.                         temp = Head;
  240.                         for (int i = 0; i < x - 1; i++)
  241.                                 temp = temp->next;
  242.                         if (temp->next != NULL)
  243.                         {
  244.                                 node* temp2 = new node;
  245.                                 temp2 = temp->next;
  246.                                 while (temp2)
  247.                                 {
  248.                                         node* temp3 = new node;
  249.                                         temp3 = temp2;
  250.                                         temp2 = temp2->next;
  251.                                         delete temp3;
  252.                                 }
  253.                                 delete temp2;
  254.                         }
  255.                         temp->next = NULL;
  256.                         Tail = temp;
  257.                 }
  258.                 else
  259.                         for (int i = 0; i < x - size; i++)
  260.                                 this->push_back(0);
  261.         }
  262.         int listsize()
  263.         {
  264.                 return size;
  265.         }
  266.         void swap();
  267.         //Операторы
  268.         void operator=(mylist& list)
  269.         {
  270.                 this->clear();
  271.                 node* temp = new node;
  272.                 temp = list.Head;
  273.                 while (temp)
  274.                 {
  275.                         this->push_back(temp->data);
  276.                         temp = temp->next;
  277.                 }
  278.                 delete temp;
  279.         }
  280. private:
  281.         bool operator==(mylist& list)
  282.         {
  283.                 int count = 0;
  284.                 node* temp = new node;
  285.                 temp = Head;
  286.                 node* templist = new node;
  287.                 templist = list.Head;
  288.                 while ((temp) && (templist))
  289.                 {
  290.                         if (temp->data == templist->data)
  291.                                 count++;
  292.                         temp = temp->next;
  293.                         templist = templist->next;
  294.                 }
  295.                 if (temp == NULL)
  296.                         delete temp;
  297.                 if (templist == NULL)
  298.                         delete templist;
  299.                 if (count == size)
  300.                         return 1;
  301.                 else return 0;
  302.         }
  303.         bool operator!=(mylist& list)
  304.         {
  305.                 int count = 0;
  306.                 node* temp = new node;
  307.                 temp = Head;
  308.                 node* templist = new node;
  309.                 templist = list.Head;
  310.                 while ((temp) && (templist))
  311.                 {
  312.                         if (temp->data == templist->data)
  313.                                 count++;
  314.                         temp = temp->next;
  315.                         templist = templist->next;
  316.                 }
  317.                 if (temp == NULL)
  318.                         delete temp;
  319.                 if (templist == NULL)
  320.                         delete templist;
  321.                 if (count == size)
  322.                         return 0;
  323.                 else return 1;
  324.         }
  325. };

Share with your friends:

Print