public class DoublyNode<T>
    {
        private T value;
        private DoublyNode<T> previous;
        private DoublyNode<T> next;

        public T Value
        {
            get { return value; }
            set { this.value = value; }
        }

        public DoublyNode<T> Previous
        {
            get { return previous; }
            set { this.previous = value; }
        }

        public DoublyNode<T> Next
        {
            get { return next; }
            set { this.next = value; }
        }

        public DoublyNode(T value)
        {
            this.value = value;
        }
    }

    public class DoublyLinkedList<T>
    {
        private DoublyNode<T> head;
        private DoublyNode<T> tail;

        public DoublyLinkedList()
        {
            this.head = null;
            this.tail = null;
        }

        public DoublyNode<T> Head
        {
            get { return head; }
        }

        public DoublyNode<T> Tail
        {
            get { return tail; }
        }

        public DoublyNode<T> Search(T value)
        {
            DoublyNode<T> cursor = head;


            while (cursor != null && !EqualityComparer<T>.Default.Equals(cursor.Value, value))
            {
                cursor = cursor.Next;
            }

            return cursor;
        }

        public void InsertStart(T value)
        {
            DoublyNode<T> node = new DoublyNode<T>(value);

            if (head != null)
            {
                node.Next = head;
                head.Previous = node;
                head = node;
            }
            else
            {
                tail = node;
                head = node;
                return;
            }
        }

        public void InsertEnd(T value)
        {
            DoublyNode<T> node = new DoublyNode<T>(value);

            if (tail != null)
            {
                node.Previous = tail;
                tail.Next = node;
                tail = node;
            }
            else
            {
                tail = node;
                head = node;
                return;
            }
        }

        public void DeleteFirst()
        {
            if (head != null)
            {
                head = head.Next;
                head.Previous = null;
            }
        }

        public void DeleteEnd()
        {
            if (tail != null)
            {
                tail = tail.Previous;
                tail.Next = null;
            }
        }

        public bool InsertAfter(T insert, T value)
        {
            if (insert == null || value == null)
                return false;

            DoublyNode<T> node = Search(insert);

            if (node == null) //didn't find exisinting node
                return false;

            DoublyNode<T> newNode = new DoublyNode<T>(value);
            newNode.Previous = node;

            if (node.Next != null)
                node.Next.Previous = newNode;

            newNode.Next = node.Next;
            node.Next = newNode;

            return true;
        }

        public bool InsertBefore(T insert, T value)
        {
            if (insert == null || value == null)
                return false;

            DoublyNode<T> node = Search(insert);

            if (node == null) //didn't find exisinting node
                return false;

            DoublyNode<T> newNode = new DoublyNode<T>(value);
            newNode.Next = node;

            if (node.Previous != null)
                node.Previous.Next = newNode;

            newNode.Previous = node.Next;
            node.Previous = newNode;

            return true;
        }

        public bool Remove(T value)
        {
            DoublyNode<T> node = Search(value);

            if (node == null)
                return false;

            if (node.Previous == null)
                head = head.Next;
            else
                node.Previous.Next = node.Next;

            if (node.Next == null)
                tail = tail.Previous;
            else
                node.Next.Previous = node.Previous;

            return true;
        }
    }

    public class SinglyNode<T>
    {
        private T value;
        private SinglyNode<T> next;

        public T Value
        {
            get { return value; }
            set { this.value = value; }
        }

        public SinglyNode<T> Next
        {
            get { return next; }
            set { this.next = value; }
        }

        public SinglyNode(T value)
        {
            this.value = value;
        }

    }

    public class SinglyLinkedList<T>
    {
        private SinglyNode<T> head;

        public SinglyLinkedList()
        {
            this.head = null;
        }

        public SinglyNode<T> Head
        {
            get { return head; }
        }

        public void Insert(T value)
        {
            SinglyNode<T> node = new SinglyNode<T>(value);
            node.Next = head;
            head = node;
        }

        public void Delete()
        {
            if (head != null)
                head = head.Next;
        }
    }