From 236314abe7c49917576d2b799ce6a8a7deaa1a8c Mon Sep 17 00:00:00 2001
From: Mina Asham <mina.asham@hotmail.com>
Date: Sun, 3 May 2015 22:04:42 +0100
Subject: [PATCH] Adding Stack and Queue to algs4 (List based)

---
 algs4/algs4.csproj   |   2 +
 algs4/algs4/Queue.cs | 213 +++++++++++++++++++++++++++++++++++++++++++
 algs4/algs4/Stack.cs | 200 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 415 insertions(+)
 create mode 100644 algs4/algs4/Queue.cs
 create mode 100644 algs4/algs4/Stack.cs

diff --git a/algs4/algs4.csproj b/algs4/algs4.csproj
index 5c09430..7018714 100644
--- a/algs4/algs4.csproj
+++ b/algs4/algs4.csproj
@@ -65,9 +65,11 @@
     <Compile Include="algs4\GraphGenerator.cs" />
     <Compile Include="algs4\MinPQ.cs" />
     <Compile Include="algs4\PictureDump.cs" />
+    <Compile Include="algs4\Queue.cs" />
     <Compile Include="algs4\RedBlackBST.cs" />
     <Compile Include="algs4\Set.cs" />
     <Compile Include="algs4\ST.cs" />
+    <Compile Include="algs4\Stack.cs" />
     <Compile Include="algs4\StaticSETofInts.cs" />
     <Compile Include="algs4\SymbolDigraph.cs" />
     <Compile Include="algs4\TopM.cs" />
diff --git a/algs4/algs4/Queue.cs b/algs4/algs4/Queue.cs
new file mode 100644
index 0000000..a21fb3a
--- /dev/null
+++ b/algs4/algs4/Queue.cs
@@ -0,0 +1,213 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using algs4.stdlib;
+
+namespace algs4.algs4
+{
+    public class Queue<TItem> : IEnumerable<TItem>
+    {
+        /// <summary>
+        /// Number of elements on queue
+        /// </summary>
+        private int _n;
+
+        /// <summary>
+        /// Beginning of queue
+        /// </summary>
+        private Node<TItem> _first;
+
+        /// <summary>
+        /// End of queue
+        /// </summary>
+        private Node<TItem> _last;
+
+        /// <summary>
+        /// Helper linked list class
+        /// </summary>
+        /// <typeparam name="TItemInner"></typeparam>
+        private class Node<TItemInner>
+        {
+            public TItemInner Item { get; set; }
+            public Node<TItemInner> Next { get; set; }
+        }
+
+        /// <summary>
+        /// Initializes an empty queue.
+        /// </summary>
+        public Queue()
+        {
+            _first = null;
+            _last = null;
+            _n = 0;
+        }
+
+        /// <summary>
+        /// Is this queue empty?
+        /// </summary>
+        /// <returns>true if this queue is empty; false otherwise</returns>
+        public bool IsEmpty()
+        {
+            return _first == null;
+        }
+
+        /// <summary>
+        /// Returns the number of items in this queue.
+        /// </summary>
+        /// <returns>the number of items in this queue</returns>
+        public int Size()
+        {
+            return _n;
+        }
+
+        /// <summary>
+        /// Returns the item least recently added to this queue.
+        /// </summary>
+        /// <returns>the item least recently added to this queue</returns>
+        public TItem Peek()
+        {
+            if (IsEmpty())
+            {
+                throw new InvalidOperationException("Queue underflow");
+            }
+            return _first.Item;
+        }
+
+        /// <summary>
+        /// Adds the item to this queue.
+        /// </summary>
+        /// <param name="item">the item to add</param>
+        public void Enqueue(TItem item)
+        {
+            Node<TItem> oldlast = _last;
+            _last = new Node<TItem>();
+            _last.Item = item;
+            _last.Next = null;
+            if (IsEmpty())
+            {
+                _first = _last;
+            }
+            else
+            {
+                oldlast.Next = _last;
+            }
+            _n++;
+        }
+
+        /// <summary>
+        /// Removes and returns the item on this queue that was least recently added.
+        /// </summary>
+        /// <returns>the item on this queue that was least recently added</returns>
+        public TItem Dequeue()
+        {
+            if (IsEmpty())
+            {
+                throw new InvalidOperationException("Queue underflow");
+            }
+            TItem item = _first.Item;
+            _first = _first.Next;
+            _n--;
+            if (IsEmpty())
+            {
+                // to avoid loitering
+                _last = null;
+            }
+            return item;
+        }
+
+        /// <summary>
+        /// Returns a string representation of this queue.
+        /// </summary>
+        /// <returns>the sequence of items in FIFO order, separated by spaces</returns>
+        public override string ToString()
+        {
+            StringBuilder s = new StringBuilder();
+            foreach (TItem item in this)
+            {
+                s.Append(item + " ");
+            }
+            return s.ToString();
+        }
+
+        /// <summary>
+        /// Returns an iterator that iterates over the items in this queue in FIFO order.
+        /// </summary>
+        /// <returns>an iterator that iterates over the items in this queue in FIFO order</returns>
+        public IEnumerator<TItem> GetEnumerator()
+        {
+            return new ListIterator<TItem>(_first);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        /// <summary>
+        /// An iterator
+        /// </summary>
+        /// <typeparam name="TItemInner"></typeparam>
+        private class ListIterator<TItemInner> : IEnumerator<TItemInner>
+        {
+            private readonly Node<TItemInner> _first;
+            private Node<TItemInner> _current;
+
+            public TItemInner Current { get; private set; }
+
+            object IEnumerator.Current
+            {
+                get { return Current; }
+            }
+
+            public ListIterator(Node<TItemInner> first)
+            {
+                _first = first;
+                Reset();
+            }
+
+            public bool MoveNext()
+            {
+                bool hasNext = _current != null;
+                if (hasNext)
+                {
+                    Current = _current.Item;
+                    _current = _current.Next;
+                }
+
+                return hasNext;
+            }
+
+            public void Reset()
+            {
+                _current = _first;
+            }
+            public void Dispose()
+            {
+                _current = null;
+            }
+        }
+
+        /// <summary>
+        /// Unit tests the Queue data type.
+        /// </summary>
+        /// <param name="args"></param>
+        public static void RunMain(string[] args)
+        {
+            Queue<string> q = new Queue<string>();
+            while (!StdIn.IsEmpty())
+            {
+                string item = StdIn.ReadString();
+                if (item != "-")
+                {
+                    q.Enqueue(item);
+                }
+                else if (!q.IsEmpty())
+                {
+                    StdOut.Print(q.Dequeue() + " ");
+                }
+            }
+            StdOut.PrintLn("(" + q.Size() + " left on queue)");
+        }
+    }
+}
diff --git a/algs4/algs4/Stack.cs b/algs4/algs4/Stack.cs
new file mode 100644
index 0000000..6857626
--- /dev/null
+++ b/algs4/algs4/Stack.cs
@@ -0,0 +1,200 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using algs4.stdlib;
+
+namespace algs4.algs4
+{
+    public class Stack<TItem> : IEnumerable<TItem>
+    {
+        /// <summary>
+        /// Size of the stack
+        /// </summary>
+        private int _n;
+
+        /// <summary>
+        /// Top of stack
+        /// </summary>
+        private Node<TItem> _first;
+
+        /// <summary>
+        /// Helper linked list class
+        /// </summary>
+        /// <typeparam name="TItemInner"></typeparam>
+        private class Node<TItemInner>
+        {
+            public TItemInner Item { get; set; }
+            public Node<TItemInner> Next { get; set; }
+        }
+
+        /// <summary>
+        /// Initializes an empty stack.
+        /// </summary>
+        public Stack()
+        {
+            _first = null;
+            _n = 0;
+        }
+
+        /// <summary>
+        /// Is this stack empty?
+        /// </summary>
+        /// <returns>true if this stack is empty; false otherwise</returns>
+        public bool IsEmpty()
+        {
+            return _first == null;
+        }
+
+        /// <summary>
+        /// Returns the number of items in the stack.
+        /// </summary>
+        /// <returns>the number of items in the stack</returns>
+        public int Size()
+        {
+            return _n;
+        }
+
+        /// <summary>
+        /// Adds the item to this stack.
+        /// </summary>
+        /// <param name="item">item the item to add</param>
+        public void Push(TItem item)
+        {
+            Node<TItem> oldfirst = _first;
+            _first = new Node<TItem>();
+            _first.Item = item;
+            _first.Next = oldfirst;
+            _n++;
+        }
+
+        /// <summary>
+        /// Removes and returns the item most recently added to this stack.
+        /// </summary>
+        /// <returns>the item most recently added</returns>
+        public TItem Pop()
+        {
+            if (IsEmpty())
+            {
+                throw new InvalidOperationException("Stack underflow");
+            }
+
+            // save item to return
+            TItem item = _first.Item;
+
+            // delete first node
+            _first = _first.Next;
+            _n--;
+
+            // return the saved item
+            return item;
+        }
+
+        /// <summary>
+        /// Returns (but does not remove) the item most recently added to this stack.
+        /// </summary>
+        /// <returns>the item most recently added to this stack</returns>
+        public TItem Peek()
+        {
+            if (IsEmpty())
+            {
+                throw new InvalidOperationException("Stack underflow");
+            }
+            return _first.Item;
+        }
+
+        /// <summary>
+        /// Returns a string representation of this stack.
+        /// </summary>
+        /// <returns>the sequence of items in the stack in LIFO order, separated by spaces</returns>
+        public override string ToString()
+        {
+            StringBuilder s = new StringBuilder();
+            foreach (TItem item in this)
+            {
+                s.Append(item + " ");
+            }
+            return s.ToString();
+        }
+
+        /// <summary>
+        /// Returns an iterator to this stack that iterates through the items in LIFO order.
+        /// </summary>
+        /// <returns>an iterator to this stack that iterates through the items in LIFO order.</returns>
+        public IEnumerator<TItem> GetEnumerator()
+        {
+            return new ListIterator<TItem>(_first);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        /// <summary>
+        /// An iterator
+        /// </summary>
+        /// <typeparam name="TItemInner"></typeparam>
+        private class ListIterator<TItemInner> : IEnumerator<TItemInner>
+        {
+            private readonly Node<TItemInner> _first;
+            private Node<TItemInner> _current;
+
+            public TItemInner Current { get; private set; }
+
+            object IEnumerator.Current
+            {
+                get { return Current; }
+            }
+
+            public ListIterator(Node<TItemInner> first)
+            {
+                _first = first;
+                Reset();
+            }
+
+            public bool MoveNext()
+            {
+                bool hasNext = _current != null;
+                if (hasNext)
+                {
+                    Current = _current.Item;
+                    _current = _current.Next;
+                }
+
+                return hasNext;
+            }
+
+            public void Reset()
+            {
+                _current = _first;
+            }
+            public void Dispose()
+            {
+                _current = null;
+            }
+        }
+
+        /// <summary>
+        /// Unit tests the <tt>Stack</tt> data type.
+        /// </summary>
+        /// <param name="args"></param>
+        public static void RunMain(string[] args)
+        {
+            Stack<string> s = new Stack<string>();
+            while (!StdIn.IsEmpty())
+            {
+                string item = StdIn.ReadString();
+                if (item != "-")
+                {
+                    s.Push(item);
+                }
+                else if (!s.IsEmpty())
+                {
+                    StdOut.Print(s.Pop() + " ");
+                }
+            }
+            StdOut.PrintLn("(" + s.Size() + " left on stack)");
+        }
+    }
+}