S11as

mp2-lab14-tables

Apr 8th, 2021
554
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <cmath>
  2. #include <iostream>
  3. #include <stack>
  4. #include <string.h>
  5. #include <vector>
  6.  
  7. template <class TK, class TV> class TMap;
  8.  
  9. template <class TK, class TV>
  10.  
  11. class TNode {
  12. protected:
  13.     TK key;
  14.     TV val;
  15.  
  16. public:
  17.     TNode(TK k = 0, TV v = 0);
  18.     TNode(const TNode &p);
  19.  
  20.     TK GetKey();
  21.     TV GetVal();
  22.  
  23.     void SetKey(TK k);
  24.     void SetVal(TV v);
  25.  
  26.     TNode &operator=(const TNode &p);
  27.  
  28.     bool operator==(TNode &p);
  29.     bool operator>(TNode &p);
  30.     bool operator<(TNode &p);
  31.  
  32.     friend class TMap<TK, TV>;
  33. };
  34.  
  35. //Витулин Иван
  36. template <class TK, class TV> TNode<TK, TV>::TNode(TK k, TV v) {
  37.     key = k;
  38.     val = v;
  39. }
  40.  
  41. template <class TK, class TV> TNode<TK, TV>::TNode(const TNode &p) {
  42.     key = p.key;
  43.     val = p.val;
  44. }
  45.  
  46. //Китаев Павел Иванович
  47.  
  48. template <class TK, class TV> TK TNode<TK, TV>::GetKey() {
  49.     return key;
  50. }
  51.  
  52. template <class TK, class TV> TV TNode<TK, TV>::GetVal() {
  53.     return val;
  54. }
  55.  
  56. template <class TK, class TV> void TNode<TK, TV>::SetKey(TK k) {
  57.     key = k;
  58. }
  59.  
  60. template <class TK, class TV> void TNode<TK, TV>::SetVal(TV v) {
  61.     val = v;
  62. }
  63.  
  64. //Кургузиков Кирилл Александрович
  65.  
  66. template <class TK, class TV> bool TNode<TK, TV>::operator==(TNode &p) {
  67.     bool res = false;
  68.  
  69.     if (p.key == this->key)
  70.         res = true;
  71.  
  72.     return res;
  73. }
  74.  
  75. template <class TK, class TV> bool TNode<TK, TV>::operator>(TNode &p) {
  76.     bool res = false;
  77.  
  78.     if (p.key > this->key)
  79.         res = true;
  80.  
  81.     return res;
  82. }
  83.  
  84. template <class TK, class TV> bool TNode<TK, TV>::operator<(TNode &p) {
  85.     bool res = false;
  86.  
  87.     if (p.key < this->key)
  88.         res = true;
  89.  
  90.     return res;
  91. }
  92.  
  93. template <class TK, class TV>
  94. TNode<TK, TV> &TNode<TK, TV>::operator=(const TNode<TK, TV> &p) {
  95.     this->key = p.key;
  96.     this->val = p.val;
  97.     return *this;
  98. }
  99.  
  100. template <class TK, class TV> class TMap {
  101. protected:
  102.     TNode<TK, TV> *mas;
  103.     int size;
  104.     int count;
  105.  
  106.     void Resize(int newSize);
  107.  
  108. public:
  109.     TMap(int size_ = 1000);
  110.     TMap(const TMap &p);
  111.     virtual ~TMap();
  112.  
  113.     virtual TV &operator[](TK i);
  114.  
  115.     virtual TV Find(TK k);
  116.     virtual void Delete(TK k);
  117.     virtual void Add(TK k, TV v);
  118.  
  119.     friend class TNode<TK, TV>;
  120. };
  121.  
  122. template <class TK, class TV> void TMap<TK, TV>::Resize(int newSize) {
  123.     TNode<TK, TV> *tmp;
  124.     tmp = new TNode<TK, TV>[newSize];
  125.     for (int i = 0; i < std::min(this->size, newSize); i++)
  126.         tmp[i] = mas[i];
  127.     delete[] mas;
  128.     mas = tmp;
  129.     this->size = newSize;
  130. }
  131.  
  132.  
  133. template <class TK, class TV> TMap<TK, TV>::TMap(int size_) {
  134.     this->size = size_;
  135.     if (size_ <= 0)
  136.         throw - 1;
  137.     else
  138.         mas = new TNode<TK, TV>[size];
  139. }
  140.  
  141.  
  142. template <class TK, class TV> TMap<TK, TV>::TMap(const TMap<TK, TV> &p) {
  143.     this->size = p.size;
  144.     this->count = p.count;
  145.     this->mas = new TNode<TK, TV>[p.size];
  146.     for (int i = 0; i < p.count; i++)
  147.         this->mas[i] = p.mas[i];
  148. }
  149.  
  150. template <class TK, class TV>
  151. TMap<TK, TV>::~TMap() {
  152.     if (mas != nullptr)
  153.         delete[] mas;
  154.     mas = nullptr;
  155.     size = 0;
  156.     count = 0;
  157. }
  158.  
  159. template <class TK, class TV>
  160. TV &TMap<TK, TV>::operator[](TK i) {
  161.     for (size_t j = 0; j < count; j++) {
  162.         if (mas[j].key == i) {
  163.             return mas[j].val;
  164.         }
  165.     }
  166.     mas[count].key = i;
  167.     mas[count].val = 0;
  168.     count++;
  169.     if (count == size)
  170.         Resize(size * 2);
  171.   return mas[count-1].val;
  172. }
  173.  
  174. template <class TK, class TV>
  175. TV TMap<TK, TV>::Find(TK k) {
  176.     for (int i = 0; i < this->count; i++) {
  177.         if (mas[i].key == k)
  178.             return this->mas[i].val;
  179.     }
  180.     throw - 1;
  181. }
  182.  
  183. template <class TK, class TV> void TMap<TK, TV>::Delete(TK k) {
  184.     for (int i = 0; i < count; i++) {
  185.         if (mas[i].key == k) {
  186.             for (int j = i; j < count - 1; j++) {
  187.                 mas[j] = mas[j + 1];
  188.             }
  189.         }
  190.     }
  191. }
  192.  
  193. template <class TK, class TV> void TMap<TK, TV>::Add(TK k, TV v) {
  194.     mas[count].key = k;
  195.     mas[count].val = v;
  196.     count++;
  197.     if (count == size)
  198.         Resize(size * 2);
  199. }
  200.  
  201. template <class TK, class TV>
  202. class TIterSortMap
  203.  
  204. template <class TK, class TV>
  205. class TSortMap : public TMap<TK, TV>
  206. {
  207. public:
  208.     TSortMap(int size_ = 1000);
  209.   TSortMap(int size_, TNode<TK,TV>* m);
  210.     TSortMap(const TSortMap &p);
  211.  
  212.     virtual TV &operator[](TK i);
  213.  
  214.     virtual TV Find(TK k);
  215.     virtual void Delete(TK k);
  216.     virtual void Add(TK k, TV v);
  217.  
  218.     friend class TNode<TK, TV>;
  219.   friend class TIterSortMap <TK, TV>;
  220.  
  221.   TIterSortMap<TK, TV> GetBegin()
  222.   {
  223.     TIterSortMap<TK, TV> res(*this);
  224.     return res;
  225.   }
  226.      
  227. };
  228.  
  229. //Горбачев Артем
  230.   template <class TK, class TV> TSortMap<TK, TV>::TSortMap(int size_, TNode<TK,TV>* m)
  231.   {
  232.     TNode<TK, TV> *&mas = this->mas;
  233.     mas = new TNode<TK, TV>[size_];
  234.     for (int i = 0; i < size_; i++)
  235.       mas[i] = m[i];
  236.     TNode<TK,TV> tmp;
  237.     for (int i = size_ - 1; i > 0; i--)
  238.       for (int j = 0; j < i; j++)
  239.         if (mas[j] < mas[j+1]) {
  240.           tmp = mas[j];
  241.           mas[j] = mas[j+1];
  242.           mas[j+1] = tmp;
  243.         }
  244.   }
  245.  
  246. //Галиндо Толедо Хавьер Эдуардо
  247.     template <class TK, class TV> TSortMap<TK, TV>::TSortMap(int size_):TMap<TK, TV>::TMap(size_)
  248.   {
  249.    
  250. }
  251.  
  252.  
  253. //Ким Никита
  254.     template <class TK, class TV> TSortMap<TK, TV>::TSortMap(const TSortMap &p):TMap<TK, TV>::TMap(p)
  255.   {
  256.  
  257.   }
  258.  
  259.     template <class TK, class TV>
  260.    TV& TSortMap<TK, TV>::operator[](TK i)
  261.   {
  262.  
  263.     int l = 0;
  264.     int r = this->count -1;
  265.    
  266.     while (l-r > 0)
  267.     {
  268.       int c = (l + r) / 2;
  269.       if (this->mas[c].key == i)
  270.         return this->mas[c].val;
  271.       if (this->mas[c].key > i)
  272.       {
  273.         r = c;
  274.       }
  275.       else
  276.       {
  277.         l = c;
  278.       }
  279.     }
  280.     if (this->mas[l].key == i)
  281.       return this->mas[l].val;
  282.     else
  283.       throw -1;
  284.   }
  285. //Колосова Алена
  286.     template <class TK, class TV>
  287.   TV TSortMap<TK, TV>::Find(TK k)
  288.   {
  289.     int l=0, r=this->count;
  290.     int c;
  291.     while(l<r){
  292.       c=(l+r)/2;
  293.       if (k==this->mas[c].GetKey())
  294.         return this->mas[c].GetVal();
  295.       if(k<this->mas[c].GetKey()){
  296.         r=c;
  297.       }
  298.       else{
  299.         l=c;
  300.       }
  301.     }
  302.     throw -1;
  303.   }
  304.  
  305. //Китаев Павел Иванович
  306.     template <class TK, class TV>
  307.   void TSortMap<TK, TV>::Delete(TK k)
  308.   {
  309.     int ind = -1;
  310.     int l=0, r=this->size - 1;
  311.     while(l<=r){
  312.       int mid = (l+r)/2;
  313.       if(this->mas[mid].key <= k)
  314.         l = mid + 1;
  315.       else
  316.         r = mid - 1;
  317.     }
  318.  
  319.     if (ind != -1)
  320.     {
  321.       for (int i = ind; i < this->count-1; i++)
  322.           this->mas[i] = this->mas[i+1];
  323.      
  324.       this->mas[this->count].key = NULL;
  325.       this->mas[this->count].val = NULL;
  326.         }
  327.   }
  328.  
  329. //Круглов Алексей
  330.     template <class TK, class TV>
  331.   void TSortMap<TK, TV>::Add(TK k, TV v)
  332.   {
  333.     int ind = -1;
  334.     TNode node(k,v);
  335.     int l=0, r =this->size - 1;
  336.     while(l<=r){
  337.       int mid = (l+r)/2;
  338.       if(this->mas[mid] < node){
  339.         l = mid + 1;
  340.         ind = mid;
  341.       }else{
  342.         r = mid - 1;
  343.       }
  344.     }
  345.    
  346.     if(ind == -1)
  347.       ind = this->count;
  348.    
  349.     this->count++;
  350.    
  351.     if(this->count >= this->size)
  352.       Resize(2*this->size);
  353.    
  354.     for(int i=this->count; i>= ind; i--){
  355.       this->mas[i] = this->mas[i-1];
  356.     }
  357.     this->mas[ind] = node;
  358.   }
  359.  
  360.  
  361.  
  362.   //Мясникова Варвара
  363. template <class TK, class TV>
  364. class TIterSortMap
  365. {
  366. protected:
  367. TSortMap<TK,TV> &map;
  368. int index;
  369. public:
  370.   TIterSortMap  TIterSortMap(TSortMap<TK,TV>& p)   : map(p), index(0)
  371.   {}
  372.   TIterSortMap GoNext();
  373.   TIterSortMap IsGoNext();
  374.  
  375.  };
  376.  
  377. //Ремизова Антонина
  378.    TIterSortMap GoNext()
  379.    {
  380.      
  381.    }
  382.  
  383. ////Ганга Мукела Брекс Джуниор
  384.   TIterSortMap IsGoNext();
  385.  
  386.  
  387. int main() {
  388.     TMap<char, double> m;
  389.     m.Add('a', 11.254);
  390.     m.Add('b', 22.78);
  391.     m.Add('c', 33.998);
  392.  
  393.     std::cout << m.Find('b') << "\n";
  394.     std::cout << m['c'] << "\n";
  395.  
  396.     return 0;
  397. }
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×