Firat Atagun

Naive implementation of Stack in C# uses array. In this post, I have implemented the stack with LinkedList. This implementation is not thread safe.

using System;
using System.Collections;
using System.Collections.Generic;

namespace CodeCodeCode
{
    public class StackLinkedList : IEnumerable, ICollection
    {
        private readonly LinkedList _container;

        public StackLinkedList()
        {
            _container = new LinkedList();
        }

        public StackLinkedList(IEnumerable collection)
        {
            foreach (T element in collection)
            {
                _container.AddLast(element);
            }
        }

        public StackLinkedList(Stack _stack)
        {
            while (_stack.Count > 0)
            {
                T element = _stack.Pop();

                _container.AddLast(element);
            }
        }

        #region ICollection Members

        public void Add(T item)
        {
            throw new NotImplementedException();
        }

        public void Clear()
        {
            _container.Clear();
        }

        public bool Contains(T item)
        {
            return _container.Contains(item);
        }

        public void CopyTo(T[] array, int arrayIndex)
        {
            throw new NotImplementedException();
        }

        int ICollection.Count
        {
            get { return _container.Count; }
        }

        public bool IsReadOnly
        {
            get { return false; }
        }

        public bool Remove(T item)
        {
            return _container.Remove(item);
        }

        #endregion

        #region IEnumerable Members

        public IEnumerator GetEnumerator()
        {
            foreach (T element in _container)
            {
                yield return element;
                _container.Remove(element);
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        #endregion

        public T Pop()
        {
            LinkedListNode element = _container.First;

            _container.Remove(element);

            return element.Value;
        }

        public void Push(T element)
        {
            _container.AddFirst(element);
        }

        public T Peek()
        {
            return _container.First.Value;
        }

        public int Count()
        {
            return _container.Count;
        }
    }
}
    [TestClass]
    public class UnitTest1
    {

        private StackLinkedList _collection;

        public UnitTest1()
        {
            _collection = new StackLinkedList();
        }

        [TestMethod]
        public void PushMethod()
        {
             _collection.Push(1);
             _collection.Push(2);
             _collection.Push(3);
            Assert.AreEqual(3, _collection.Peek());
            Assert.AreEqual(3, _collection.Pop());
            Assert.AreEqual(2, _collection.Pop());
            Assert.AreEqual(1, _collection.Pop());
            Assert.AreEqual(0, _collection.Count());
        }

    }