Coada circulara

ASD/Queue.cs

@@ -27,29 +27,41 @@ public Queue(int capacity)
             this.capacity = capacity;
             data = new Item[capacity];
         }
+        int nextPoz(int index)
+        {
+            if (index < capacity - 1)
+                return index + 1;
+            else
+                return 0;
+        }
         /// <summary>
         /// Adaugarea unui element in coada
         /// </summary>
         /// <param name="item">Elementul ce se adauga</param>
         public void enqueue(Item item)
         {
-            if (right < capacity - 1)
-                data[right++] = item;
-            else
+            if (left == nextPoz(right))
                 throw new QueueFullException();
-        }
+            else
+                data[right] = item;
+            right = nextPoz(right);
+
+         } 
         /// <summary>
         /// Eliminarea elementului care a fost adaugat cel mai demult
         /// </summary>
         /// <returns></returns>
         public Item dequeue()
         {
-            if (left < right)
-                return data[left++];
-            else
+            Item x;
+            if (left == right)
                 throw new QueueEmptyException();
+            else
+                x = data[left];
+            left = nextPoz(left);
+            return x;
         }
-        /// <summary>
+         /// <summary>
         /// Este goala coada?
         /// </summary>
         /// <returns></returns>
@@ -63,22 +75,27 @@ public bool isEmpty()
         /// <returns></returns>
         public int size()
         {
+            if(left<right)
             return right - left;
+            else
+            return left-right;
         }
-        public static void Main(string[] args)
-        {
-            Queue<Date> queue = new Queue<Date>();
-            queue.enqueue(new Date(31, 12, 1999));
-
-            Date next = queue.dequeue();
-        }
-
         public IEnumerator<Item> GetEnumerator()
         {
-            for (int i = left; i < right; i++)
+            if (left < right)
             {
-                yield return data[i];
+                for (int i = left; i < right; i++)
+                    yield return data[i];
             }
+            else
+            {
+                for (int j = 0; j < right; j++)
+                    yield return data[j];
+                for (int i = left; i < capacity; i++)
+                    yield return data[i];
+
+            }
+
         }
 
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

ASD/ResizingBag.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ASD
+{
+    class ResizingBag<Item>: IEnumerable<Item>
+    {
+        private Item[] data;
+        private int count = 0;
+        private int capacity = 25;
+        /// <summary>
+        /// Crearea unui Bag fara nici un element
+        /// </summary>
+        public ResizingBag()
+        {
+            data = new Item[capacity];
+        }
+        public ResizingBag(int capacity)
+        {
+            this.capacity = capacity;
+            data = new Item[capacity];
+        }
+        /// <summary>
+        /// Redimensionare Bag
+        /// </summary>
+        /// <param name="max">Noua dimensiune a bag-lui</param>
+        private void resize(int max)
+        {
+            Item[] temp = new Item[max];
+            for (int i = 0; i < count; i++)
+            {
+                temp[i] = data[i];
+            }
+            data = temp;
+            this.capacity = max;
+        }
+        /// <summary>
+        /// Adaugarea unui element
+        /// </summary>
+        /// <param name="item"></param>
+        public void add(Item item)
+        {
+            if (count == capacity)
+            {
+                resize(2 * capacity);
+
+            }
+            else if (count == capacity / 4)
+            {
+                resize(capacity / 2);
+            }
+            data[count++] = item;
+        }
+        /// <summary>
+        /// Este gol?
+        /// </summary>
+        /// <returns></returns>
+        public bool isEmpty()
+        {
+            return count == 0;
+        }
+        /// <summary>
+        /// Numarul de elemente din Bag
+        /// </summary>
+        /// <returns></returns>
+        public int size()
+        {
+            return count;
+        }
+
+        public IEnumerator<Item> GetEnumerator()
+        {
+            for (int i = 0; i < count; i++)
+            {
+                yield return data[i];
+            }
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}

ASD/ResizingQueue.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ASD
+{
+    class ResizingQueue<Item>: IEnumerable<Item>
+    {
+        private Item[] data;
+        private int capacity = 32;
+        private int left = 0, right = 0;
+        /// <summary>
+        /// Crearea unei cozi fara nici un element
+        /// </summary>
+        public ResizingQueue()
+        {
+            data = new Item[capacity];
+        }
+        public ResizingQueue(int capacity)
+        {
+            this.capacity = capacity;
+            data = new Item[capacity];
+        }
+        /// <summary>
+        /// Redimensionare Bag
+        /// </summary>
+        /// <param name="max">Noua dimensiune a bag-lui</param>
+        private void resize(int max)
+        {
+            Item[] temp = new Item[max];
+            for (int i = left; i < right; i++)
+            {
+                temp[i] = data[i];
+            }
+            data = temp;
+            this.capacity = max;
+        }
+        /// <summary>
+        /// Adaugarea unui element in coada
+        /// </summary>
+        /// <param name="item">Elementul ce se adauga</param>
+        public void enqueue(Item item)
+        {
+            if (right == capacity)
+                resize(2 * capacity);
+
+            data[right++] = item;
+
+        }
+        /// <summary>
+        /// Eliminarea elementului care a fost adaugat cel mai demult
+        /// </summary>
+        /// <returns></returns>
+        public Item dequeue()
+        {
+            if (right == capacity / 4)
+            {
+                resize(capacity / 2);
+            }
+            if (left < right)
+                return data[left++];
+            else
+                throw new QueueEmptyException();
+        }
+        /// <summary>
+        /// Este goala coada?
+        /// </summary>
+        /// <returns></returns>
+        public bool isEmpty()
+        {
+            return left == right;
+        }
+        /// <summary>
+        /// Numarul de elemente din coada
+        /// </summary>
+        /// <returns></returns>
+        public int size()
+        {
+            return right - left;
+        }
+        public IEnumerator<Item> GetEnumerator()
+        {
+            for (int i = left; i < right; i++)
+            {
+                yield return data[i];
+            }
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+
+    class QueueEmptyException : System.Exception
+    {
+    }
+
+    class QueueFullException : System.Exception
+    {
+    }
+}