Added notes on queue and refined notes on stacks.

Author: Clément

source/code/projects/CQueue/CQueue/CQueue.cs

@@ -0,0 +1,91 @@
+using System; // This is required for the exception.
+
+class CQueue<T>
+{
+  private int front,
+    end,
+    size;
+  private T[] mArray;
+
+  public CQueue(int capacity = 10)
+  {
+    mArray = new T[capacity];
+    // Note that front, end and size
+    // are set to 0.
+  }
+
+  public void Clear()
+  {
+    front = 0;
+    end = 0;
+    size = 0;
+  }
+
+  public bool IsEmpty()
+  {
+    return size == 0;
+  }
+
+  public bool IsFull()
+  {
+    return size == mArray.Length;
+  }
+
+  public void Enqueue(T newItem)
+  {
+    if (!IsFull())
+    {
+      mArray[end] = newItem;
+      Increment(ref end);
+      size++;
+    }
+    else
+      Resize();
+  }
+
+  public T Dequeue()
+  {
+    size--;
+    T data = mArray[front];
+    Increment(ref front);
+    return data;
+  }
+
+  public void Resize()
+  {
+    throw new Exception(
+      "Queue Resize is not implemented - you could implement it"
+    );
+  }
+
+  // Increment must be done carefully:
+  // what if we reached the "end of mArray"
+  // but there is room available at the
+  // beginning of the queue? Then the value
+  // needs to become 0.
+  private void Increment(ref int value)
+  {
+    value++;
+    if (value == mArray.Length)
+    {
+      value = 0;
+    }
+  }
+
+  public int Capacity
+  {
+    get { return mArray.Length - size; }
+  }
+
+  public override string ToString()
+  {
+    string returned = "";
+    returned +=
+      $"Front : {front}, end : {end}, size : {size}, capacity: {Capacity}\n";
+    for (int i = front; i < size + front; i++)
+    {
+      returned += mArray[i % mArray.Length] + ":";
+    }
+    return returned;
+  }
+}

source/code/projects/CQueue/CQueue/Program.cs

@@ -0,0 +1,50 @@
+using System;
+
+class Program
+{
+  static void Main(string[] args)
+  {
+    /* First example. */
+    CQueue<int> myQueue1 = new CQueue<int>();
+    Console.WriteLine(myQueue1);
+    myQueue1.Enqueue(1);
+    myQueue1.Enqueue(2);
+    myQueue1.Enqueue(3);
+    myQueue1.Enqueue(4);
+    myQueue1.Enqueue(5);
+    Console.WriteLine(myQueue1);
+    Console.WriteLine(
+      "Value dequeued: " + myQueue1.Dequeue()
+    );
+    Console.WriteLine(myQueue1);
+
+    myQueue1.Enqueue(6);
+    myQueue1.Enqueue(7);
+    myQueue1.Enqueue(8);
+    myQueue1.Enqueue(9);
+    myQueue1.Enqueue(10);
+    Console.WriteLine(myQueue1);
+
+    Console.WriteLine(
+      "Value dequeued: " + myQueue1.Dequeue()
+    );
+    Console.WriteLine(myQueue1);
+    Console.WriteLine(
+      "Value dequeued: " + myQueue1.Dequeue()
+    );
+    Console.WriteLine(myQueue1);
+    myQueue1.Enqueue(11);
+    myQueue1.Enqueue(12);
+    myQueue1.Enqueue(13);
+
+    try
+    {
+      myQueue1.Enqueue(14);
+    }
+    catch (Exception ex)
+    {
+      Console.WriteLine(ex.Message);
+    }
+    Console.WriteLine(myQueue1);
+  }
+}

source/lectures/data/stack.md

@@ -19,9 +19,9 @@ The fact that it may contain the same element multiple times makes it different
 
 Generally, it has operations to…
 
-- … create an empty list,
+- … create an empty stack,
 - … test for emptiness, 
-- … obtain the value of the element at "the top" of the stak ("peek"),
+- … obtain the value of the element at "the top" of the stack ("peek"),
 - … add an element at "the top" of the stack ("push"),
 - … remove an element at "the top" of the stack ("pop").
 
@@ -30,15 +30,15 @@ Exactly like a stack of plates, stacks implement a "last in, first out" (LIFO) p
 
 ### Difference with array 
 
-Like lists, the `Stack` class serves a similar purpose than arrays, but with a few notable differences:
+Like lists, stacks serve a similar purpose to arrays, but with a few notable differences:
 
 - Stacks do not need to have a number of elements fixed ahead of time,
 - Stacks automatically expand when elements are added,
 - Stacks automatically shrink when elements are removed.
 
 ### Difference with lists
 
-However, the `Stack` class is also different from lists:
+However, stacks have difference with lists:
 
 - Only the top element's value can be read (accessed),
 - Adding and removing can only be done "on the right side", that is, at the top of the stack.

source/order

@@ -62,6 +62,8 @@
 ./lectures/data/CList.md
 ./lectures/data/CList_as_ICollection.md
 ./lectures/data/DLList.md
+./lectures/data/stack.md
+./lectures/data/queue.md
 ./lectures/misc/
 ./lectures/misc/over_under_flow.md
 ./lectures/misc/random.md